#[allow(unused_imports)]
use crate::objc::*;
#[allow(unused_imports)]
use crate::AddressBook::*;
#[allow(unused_imports)]
use crate::AudioToolbox::*;
#[allow(unused_imports)]
use crate::CoreFoundation::*;
#[allow(unused_imports)]
use crate::CoreGraphics::*;
#[allow(unused_imports)]
use crate::CoreImage::*;
#[allow(unused_imports)]
use crate::CoreMedia::*;
#[allow(unused_imports)]
use crate::CoreVideo::*;
#[allow(unused_imports)]
use crate::Foundation::*;
#[allow(unused_imports)]
use crate::IOKit::*;
#[allow(unused_imports)]
use crate::ImageIO::*;
#[allow(unused_imports)]
use crate::MediaToolbox::*;
#[allow(unused_imports)]
use crate::QuartzCore::*;
#[allow(unused_imports)]
use crate::UniformTypeIdentifiers::*;
#[allow(unused_imports)]
use libc::time_t;

#[allow(unused_imports)]
use objc2::msg_send;
pub type simd_float3 = [f32; 3usize];
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct simd_float3x3 {
    pub columns: [simd_float3; 3usize],
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct simd_float4x3 {
    pub columns: [simd_float3; 4usize],
}
pub type matrix_float3x3 = simd_float3x3;
pub type matrix_float4x3 = simd_float4x3;
pub type AVLayerVideoGravity = NSString;
pub type AVKeyValueStatus = NSInteger;
pub trait PAVAsynchronousKeyValueLoading: Sized + std::ops::Deref {
    unsafe fn statusOfValueForKey_error_(
        &self,
        key: NSString,
        outError: *mut NSError,
    ) -> AVKeyValueStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, statusOfValueForKey : key, error : outError)
    }
    unsafe fn loadValuesAsynchronouslyForKeys_completionHandler_(
        &self,
        keys: NSArray,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadValuesAsynchronouslyForKeys : keys, completionHandler : handler)
    }
}
pub type AVContentKeySystem = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContentKeySession(pub id);
impl std::ops::Deref for AVContentKeySession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContentKeySession {}
impl AVContentKeySession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), alloc) })
    }
}
impl INSObject for AVContentKeySession {}
impl PNSObject for AVContentKeySession {}
impl std::convert::TryFrom<NSObject> for AVContentKeySession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContentKeySession, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap()) };
        if is_kind_of {
            Ok(AVContentKeySession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContentKeySession")
        }
    }
}
impl IAVContentKeySession for AVContentKeySession {}
pub trait IAVContentKeySession: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn expire(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expire)
    }
    unsafe fn processContentKeyRequestWithIdentifier_initializationData_options_(
        &self,
        identifier: id,
        initializationData: NSData,
        options: NSDictionary,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, processContentKeyRequestWithIdentifier : identifier, initializationData : initializationData, options : options)
    }
    unsafe fn renewExpiringResponseDataForContentKeyRequest_(
        &self,
        contentKeyRequest: AVContentKeyRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, renewExpiringResponseDataForContentKeyRequest : contentKeyRequest)
    }
    unsafe fn makeSecureTokenForExpirationDateOfPersistableContentKey_completionHandler_(
        &self,
        persistableContentKeyData: NSData,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, makeSecureTokenForExpirationDateOfPersistableContentKey : persistableContentKeyData, completionHandler : handler)
    }
    unsafe fn invalidatePersistableContentKey_options_completionHandler_(
        &self,
        persistableContentKeyData: NSData,
        options: NSDictionary,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, invalidatePersistableContentKey : persistableContentKeyData, options : options, completionHandler : handler)
    }
    unsafe fn invalidateAllPersistableContentKeysForApp_options_completionHandler_(
        &self,
        appIdentifier: NSData,
        options: NSDictionary,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, invalidateAllPersistableContentKeysForApp : appIdentifier, options : options, completionHandler : handler)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
    unsafe fn storageURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, storageURL)
    }
    unsafe fn keySystem(&self) -> AVContentKeySystem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, keySystem)
    }
    unsafe fn contentProtectionSessionIdentifier(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentProtectionSessionIdentifier)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), new)
    }
    unsafe fn contentKeySessionWithKeySystem_(keySystem: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), contentKeySessionWithKeySystem : keySystem)
    }
    unsafe fn contentKeySessionWithKeySystem_storageDirectoryAtURL_(
        keySystem: NSString,
        storageURL: NSURL,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), contentKeySessionWithKeySystem : keySystem, storageDirectoryAtURL : storageURL)
    }
}
impl AVContentKeySession_AVContentKeyRecipients for AVContentKeySession {}
pub trait AVContentKeySession_AVContentKeyRecipients: Sized + std::ops::Deref {
    unsafe fn addContentKeyRecipient_(&self, recipient: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addContentKeyRecipient : recipient)
    }
    unsafe fn removeContentKeyRecipient_(&self, recipient: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeContentKeyRecipient : recipient)
    }
    unsafe fn contentKeyRecipients(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKeyRecipients)
    }
}
impl AVContentKeySession_AVContentKeySessionPendingExpiredSessionReports for AVContentKeySession {}
pub trait AVContentKeySession_AVContentKeySessionPendingExpiredSessionReports:
    Sized + std::ops::Deref
{
    unsafe fn pendingExpiredSessionReportsWithAppIdentifier_storageDirectoryAtURL_(
        appIdentifier: NSData,
        storageURL: NSURL,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), pendingExpiredSessionReportsWithAppIdentifier : appIdentifier, storageDirectoryAtURL : storageURL)
    }
    unsafe fn removePendingExpiredSessionReports_withAppIdentifier_storageDirectoryAtURL_(
        expiredSessionReports: NSArray,
        appIdentifier: NSData,
        storageURL: NSURL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySession").unwrap(), removePendingExpiredSessionReports : expiredSessionReports, withAppIdentifier : appIdentifier, storageDirectoryAtURL : storageURL)
    }
}
pub trait PAVContentKeySessionDelegate: Sized + std::ops::Deref {
    unsafe fn contentKeySession_didProvideContentKeyRequest_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVContentKeyRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, didProvideContentKeyRequest : keyRequest)
    }
    unsafe fn contentKeySession_didProvideRenewingContentKeyRequest_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVContentKeyRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, didProvideRenewingContentKeyRequest : keyRequest)
    }
    unsafe fn contentKeySession_didProvidePersistableContentKeyRequest_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVPersistableContentKeyRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, didProvidePersistableContentKeyRequest : keyRequest)
    }
    unsafe fn contentKeySession_didUpdatePersistableContentKey_forContentKeyIdentifier_(
        &self,
        session: AVContentKeySession,
        persistableContentKey: NSData,
        keyIdentifier: id,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, didUpdatePersistableContentKey : persistableContentKey, forContentKeyIdentifier : keyIdentifier)
    }
    unsafe fn contentKeySession_contentKeyRequest_didFailWithError_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVContentKeyRequest,
        err: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, contentKeyRequest : keyRequest, didFailWithError : err)
    }
    unsafe fn contentKeySession_shouldRetryContentKeyRequest_reason_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVContentKeyRequest,
        retryReason: NSString,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, shouldRetryContentKeyRequest : keyRequest, reason : retryReason)
    }
    unsafe fn contentKeySession_contentKeyRequestDidSucceed_(
        &self,
        session: AVContentKeySession,
        keyRequest: AVContentKeyRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, contentKeyRequestDidSucceed : keyRequest)
    }
    unsafe fn contentKeySessionContentProtectionSessionIdentifierDidChange_(
        &self,
        session: AVContentKeySession,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySessionContentProtectionSessionIdentifierDidChange : session)
    }
    unsafe fn contentKeySessionDidGenerateExpiredSessionReport_(&self, session: AVContentKeySession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySessionDidGenerateExpiredSessionReport : session)
    }
    unsafe fn contentKeySession_externalProtectionStatusDidChangeForContentKey_(
        &self,
        session: AVContentKeySession,
        contentKey: AVContentKey,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, externalProtectionStatusDidChangeForContentKey : contentKey)
    }
    unsafe fn contentKeySession_didProvideContentKeyRequests_forInitializationData_(
        &self,
        session: AVContentKeySession,
        keyRequests: NSArray,
        initializationData: NSData,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : session, didProvideContentKeyRequests : keyRequests, forInitializationData : initializationData)
    }
}
pub type AVContentKeyRequestStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContentKeyRequest(pub id);
impl std::ops::Deref for AVContentKeyRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContentKeyRequest {}
impl AVContentKeyRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeyRequest").unwrap(), alloc) })
    }
}
impl INSObject for AVContentKeyRequest {}
impl PNSObject for AVContentKeyRequest {}
impl std::convert::TryFrom<NSObject> for AVContentKeyRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContentKeyRequest, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContentKeyRequest").unwrap()) };
        if is_kind_of {
            Ok(AVContentKeyRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContentKeyRequest")
        }
    }
}
impl IAVContentKeyRequest for AVContentKeyRequest {}
pub trait IAVContentKeyRequest: Sized + std::ops::Deref {
    unsafe fn makeStreamingContentKeyRequestDataForApp_contentIdentifier_options_completionHandler_(
        &self,
        appIdentifier: NSData,
        contentIdentifier: NSData,
        options: NSDictionary,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, makeStreamingContentKeyRequestDataForApp : appIdentifier, contentIdentifier : contentIdentifier, options : options, completionHandler : handler)
    }
    unsafe fn processContentKeyResponse_(&self, keyResponse: AVContentKeyResponse)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, processContentKeyResponse : keyResponse)
    }
    unsafe fn processContentKeyResponseError_(&self, error: NSError)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, processContentKeyResponseError : error)
    }
    unsafe fn respondByRequestingPersistableContentKeyRequest(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, respondByRequestingPersistableContentKeyRequest)
    }
    unsafe fn respondByRequestingPersistableContentKeyRequestAndReturnError_(
        &self,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, respondByRequestingPersistableContentKeyRequestAndReturnError : outError)
    }
    unsafe fn status(&self) -> AVContentKeyRequestStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn identifier(&self) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn initializationData(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, initializationData)
    }
    unsafe fn options(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, options)
    }
    unsafe fn canProvidePersistableContentKey(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canProvidePersistableContentKey)
    }
    unsafe fn contentKeySpecifier(&self) -> AVContentKeySpecifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKeySpecifier)
    }
    unsafe fn contentKey(&self) -> AVContentKey
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKey)
    }
    unsafe fn originatingRecipient(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, originatingRecipient)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPersistableContentKeyRequest(pub id);
impl std::ops::Deref for AVPersistableContentKeyRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPersistableContentKeyRequest {}
impl AVPersistableContentKeyRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPersistableContentKeyRequest").unwrap(), alloc) })
    }
}
impl IAVContentKeyRequest for AVPersistableContentKeyRequest {}
impl From<AVPersistableContentKeyRequest> for AVContentKeyRequest {
    fn from(child: AVPersistableContentKeyRequest) -> AVContentKeyRequest {
        AVContentKeyRequest(child.0)
    }
}
impl std::convert::TryFrom<AVContentKeyRequest> for AVPersistableContentKeyRequest {
    type Error = &'static str;
    fn try_from(
        parent: AVContentKeyRequest,
    ) -> Result<AVPersistableContentKeyRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPersistableContentKeyRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVPersistableContentKeyRequest(parent.0))
        } else {
            Err("This AVContentKeyRequest cannot be downcasted to AVPersistableContentKeyRequest")
        }
    }
}
impl INSObject for AVPersistableContentKeyRequest {}
impl PNSObject for AVPersistableContentKeyRequest {}
impl IAVPersistableContentKeyRequest for AVPersistableContentKeyRequest {}
pub trait IAVPersistableContentKeyRequest: Sized + std::ops::Deref {
    unsafe fn persistableContentKeyFromKeyVendorResponse_options_error_(
        &self,
        keyVendorResponse: NSData,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, persistableContentKeyFromKeyVendorResponse : keyVendorResponse, options : options, error : outError)
    }
}
impl AVContentKeyRequest_AVContentKeyRequestRenewal for AVContentKeyRequest {}
pub trait AVContentKeyRequest_AVContentKeyRequestRenewal: Sized + std::ops::Deref {
    unsafe fn renewsExpiringResponseData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renewsExpiringResponseData)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContentKeyResponse(pub id);
impl std::ops::Deref for AVContentKeyResponse {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContentKeyResponse {}
impl AVContentKeyResponse {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeyResponse").unwrap(), alloc) })
    }
}
impl INSObject for AVContentKeyResponse {}
impl PNSObject for AVContentKeyResponse {}
impl std::convert::TryFrom<NSObject> for AVContentKeyResponse {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContentKeyResponse, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContentKeyResponse").unwrap()) };
        if is_kind_of {
            Ok(AVContentKeyResponse(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContentKeyResponse")
        }
    }
}
impl IAVContentKeyResponse for AVContentKeyResponse {}
pub trait IAVContentKeyResponse: Sized + std::ops::Deref {
    unsafe fn contentKeyResponseWithFairPlayStreamingKeyResponseData_(
        keyResponseData: NSData,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeyResponse").unwrap(), contentKeyResponseWithFairPlayStreamingKeyResponseData : keyResponseData)
    }
    unsafe fn contentKeyResponseWithClearKeyData_initializationVector_(
        keyData: NSData,
        initializationVector: NSData,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeyResponse").unwrap(), contentKeyResponseWithClearKeyData : keyData, initializationVector : initializationVector)
    }
    unsafe fn contentKeyResponseWithAuthorizationTokenData_(
        authorizationTokenData: NSData,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeyResponse").unwrap(), contentKeyResponseWithAuthorizationTokenData : authorizationTokenData)
    }
}
pub trait PAVContentKeyRecipient: Sized + std::ops::Deref {
    unsafe fn contentKeySession_didProvideContentKey_(
        &self,
        contentKeySession: AVContentKeySession,
        contentKey: AVContentKey,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, contentKeySession : contentKeySession, didProvideContentKey : contentKey)
    }
    unsafe fn mayRequireContentKeysForMediaDataProcessing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mayRequireContentKeysForMediaDataProcessing)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContentKeySpecifier(pub id);
impl std::ops::Deref for AVContentKeySpecifier {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContentKeySpecifier {}
impl AVContentKeySpecifier {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySpecifier").unwrap(), alloc) })
    }
}
impl INSObject for AVContentKeySpecifier {}
impl PNSObject for AVContentKeySpecifier {}
impl std::convert::TryFrom<NSObject> for AVContentKeySpecifier {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContentKeySpecifier, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContentKeySpecifier").unwrap()) };
        if is_kind_of {
            Ok(AVContentKeySpecifier(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContentKeySpecifier")
        }
    }
}
impl IAVContentKeySpecifier for AVContentKeySpecifier {}
pub trait IAVContentKeySpecifier: Sized + std::ops::Deref {
    unsafe fn initForKeySystem_identifier_options_(
        &self,
        keySystem: NSString,
        contentKeyIdentifier: id,
        options: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initForKeySystem : keySystem, identifier : contentKeyIdentifier, options : options)
    }
    unsafe fn keySystem(&self) -> AVContentKeySystem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, keySystem)
    }
    unsafe fn identifier(&self) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn options(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, options)
    }
    unsafe fn contentKeySpecifierForKeySystem_identifier_options_(
        keySystem: NSString,
        contentKeyIdentifier: id,
        options: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKeySpecifier").unwrap(), contentKeySpecifierForKeySystem : keySystem, identifier : contentKeyIdentifier, options : options)
    }
}
pub type AVExternalContentProtectionStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContentKey(pub id);
impl std::ops::Deref for AVContentKey {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContentKey {}
impl AVContentKey {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContentKey").unwrap(), alloc) })
    }
}
impl INSObject for AVContentKey {}
impl PNSObject for AVContentKey {}
impl std::convert::TryFrom<NSObject> for AVContentKey {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContentKey, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContentKey").unwrap()) };
        if is_kind_of {
            Ok(AVContentKey(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContentKey")
        }
    }
}
impl IAVContentKey for AVContentKey {}
pub trait IAVContentKey: Sized + std::ops::Deref {
    unsafe fn revoke(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, revoke)
    }
    unsafe fn contentKeySpecifier(&self) -> AVContentKeySpecifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKeySpecifier)
    }
    unsafe fn externalContentProtectionStatus(&self) -> AVExternalContentProtectionStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, externalContentProtectionStatus)
    }
}
pub type AVMediaType = NSString;
pub type AVVideoRange = NSString;
pub type AVMediaCharacteristic = NSString;
pub type AVFileType = NSString;
pub type AVFileTypeProfile = NSString;
pub type AVMetadataKeySpace = NSString;
pub type AVMetadataKey = NSString;
pub type AVVideoCodecType = NSString;
pub type AVVideoApertureMode = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariant(pub id);
impl std::ops::Deref for AVAssetVariant {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariant {}
impl AVAssetVariant {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariant").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetVariant {}
impl PNSObject for AVAssetVariant {}
impl std::convert::TryFrom<NSObject> for AVAssetVariant {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetVariant, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariant").unwrap()) };
        if is_kind_of {
            Ok(AVAssetVariant(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetVariant")
        }
    }
}
impl IAVAssetVariant for AVAssetVariant {}
pub trait IAVAssetVariant: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn peakBitRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, peakBitRate)
    }
    unsafe fn averageBitRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, averageBitRate)
    }
    unsafe fn videoAttributes(&self) -> AVAssetVariantVideoAttributes
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoAttributes)
    }
    unsafe fn audioAttributes(&self) -> AVAssetVariantAudioAttributes
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioAttributes)
    }
    unsafe fn URL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URL)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariant").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariantVideoAttributes(pub id);
impl std::ops::Deref for AVAssetVariantVideoAttributes {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariantVideoAttributes {}
impl AVAssetVariantVideoAttributes {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantVideoAttributes").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetVariantVideoAttributes {}
impl PNSObject for AVAssetVariantVideoAttributes {}
impl std::convert::TryFrom<NSObject> for AVAssetVariantVideoAttributes {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetVariantVideoAttributes, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariantVideoAttributes").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetVariantVideoAttributes(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetVariantVideoAttributes")
        }
    }
}
impl IAVAssetVariantVideoAttributes for AVAssetVariantVideoAttributes {}
pub trait IAVAssetVariantVideoAttributes: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn videoRange(&self) -> AVVideoRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRange)
    }
    unsafe fn codecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, codecTypes)
    }
    unsafe fn presentationSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, presentationSize)
    }
    unsafe fn nominalFrameRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, nominalFrameRate)
    }
    unsafe fn videoLayoutAttributes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoLayoutAttributes)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantVideoAttributes").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariantVideoLayoutAttributes(pub id);
impl std::ops::Deref for AVAssetVariantVideoLayoutAttributes {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariantVideoLayoutAttributes {}
impl AVAssetVariantVideoLayoutAttributes {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantVideoLayoutAttributes").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetVariantVideoLayoutAttributes {}
impl PNSObject for AVAssetVariantVideoLayoutAttributes {}
impl std::convert::TryFrom<NSObject> for AVAssetVariantVideoLayoutAttributes {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetVariantVideoLayoutAttributes, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariantVideoLayoutAttributes").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetVariantVideoLayoutAttributes(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetVariantVideoLayoutAttributes")
        }
    }
}
impl IAVAssetVariantVideoLayoutAttributes for AVAssetVariantVideoLayoutAttributes {}
pub trait IAVAssetVariantVideoLayoutAttributes: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn stereoViewComponents(&self) -> CMStereoViewComponents
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stereoViewComponents)
    }
    unsafe fn projectionType(&self) -> CMProjectionType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, projectionType)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantVideoLayoutAttributes").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariantAudioAttributes(pub id);
impl std::ops::Deref for AVAssetVariantAudioAttributes {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariantAudioAttributes {}
impl AVAssetVariantAudioAttributes {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantAudioAttributes").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetVariantAudioAttributes {}
impl PNSObject for AVAssetVariantAudioAttributes {}
impl std::convert::TryFrom<NSObject> for AVAssetVariantAudioAttributes {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetVariantAudioAttributes, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariantAudioAttributes").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetVariantAudioAttributes(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetVariantAudioAttributes")
        }
    }
}
impl IAVAssetVariantAudioAttributes for AVAssetVariantAudioAttributes {}
pub trait IAVAssetVariantAudioAttributes: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn renditionSpecificAttributesForMediaOption_(
        &self,
        mediaSelectionOption: AVMediaSelectionOption,
    ) -> AVAssetVariantAudioRenditionSpecificAttributes
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, renditionSpecificAttributesForMediaOption : mediaSelectionOption)
    }
    unsafe fn formatIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formatIDs)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantAudioAttributes").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariantAudioRenditionSpecificAttributes(pub id);
impl std::ops::Deref for AVAssetVariantAudioRenditionSpecificAttributes {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariantAudioRenditionSpecificAttributes {}
impl AVAssetVariantAudioRenditionSpecificAttributes {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantAudioRenditionSpecificAttributes").unwrap(), alloc)
        })
    }
}
impl INSObject for AVAssetVariantAudioRenditionSpecificAttributes {}
impl PNSObject for AVAssetVariantAudioRenditionSpecificAttributes {}
impl std::convert::TryFrom<NSObject> for AVAssetVariantAudioRenditionSpecificAttributes {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVAssetVariantAudioRenditionSpecificAttributes, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariantAudioRenditionSpecificAttributes").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetVariantAudioRenditionSpecificAttributes(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVAssetVariantAudioRenditionSpecificAttributes" ,)
        }
    }
}
impl IAVAssetVariantAudioRenditionSpecificAttributes
    for AVAssetVariantAudioRenditionSpecificAttributes
{
}
pub trait IAVAssetVariantAudioRenditionSpecificAttributes: Sized + std::ops::Deref {
    unsafe fn channelCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, channelCount)
    }
    unsafe fn isBinaural(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isBinaural)
    }
    unsafe fn isImmersive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isImmersive)
    }
    unsafe fn isDownmix(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDownmix)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetVariantQualifier(pub id);
impl std::ops::Deref for AVAssetVariantQualifier {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetVariantQualifier {}
impl AVAssetVariantQualifier {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAssetVariantQualifier {}
impl INSObject for AVAssetVariantQualifier {}
impl PNSObject for AVAssetVariantQualifier {}
impl std::convert::TryFrom<NSObject> for AVAssetVariantQualifier {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetVariantQualifier, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap()) };
        if is_kind_of {
            Ok(AVAssetVariantQualifier(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetVariantQualifier")
        }
    }
}
impl IAVAssetVariantQualifier for AVAssetVariantQualifier {}
pub trait IAVAssetVariantQualifier: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), new)
    }
    unsafe fn assetVariantQualifierWithPredicate_(predicate: NSPredicate) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), assetVariantQualifierWithPredicate : predicate)
    }
    unsafe fn assetVariantQualifierWithVariant_(variant: AVAssetVariant) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), assetVariantQualifierWithVariant : variant)
    }
    unsafe fn assetVariantQualifierForMinimumValueInKeyPath_(keyPath: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), assetVariantQualifierForMinimumValueInKeyPath : keyPath)
    }
    unsafe fn assetVariantQualifierForMaximumValueInKeyPath_(keyPath: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), assetVariantQualifierForMaximumValueInKeyPath : keyPath)
    }
    unsafe fn predicateForChannelCount_mediaSelectionOption_operatorType_(
        channelCount: NSInteger,
        mediaSelectionOption: AVMediaSelectionOption,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForChannelCount : channelCount, mediaSelectionOption : mediaSelectionOption, operatorType : operatorType)
    }
    unsafe fn predicateForBinauralAudio_mediaSelectionOption_(
        isBinauralAudio: BOOL,
        mediaSelectionOption: AVMediaSelectionOption,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForBinauralAudio : isBinauralAudio, mediaSelectionOption : mediaSelectionOption)
    }
    unsafe fn predicateForImmersiveAudio_mediaSelectionOption_(
        isImmersiveAudio: BOOL,
        mediaSelectionOption: AVMediaSelectionOption,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForImmersiveAudio : isImmersiveAudio, mediaSelectionOption : mediaSelectionOption)
    }
    unsafe fn predicateForDownmixAudio_mediaSelectionOption_(
        isDownmixAudio: BOOL,
        mediaSelectionOption: AVMediaSelectionOption,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForDownmixAudio : isDownmixAudio, mediaSelectionOption : mediaSelectionOption)
    }
    unsafe fn predicateForPresentationWidth_operatorType_(
        width: CGFloat,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForPresentationWidth : width, operatorType : operatorType)
    }
    unsafe fn predicateForPresentationHeight_operatorType_(
        height: CGFloat,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForPresentationHeight : height, operatorType : operatorType)
    }
    unsafe fn predicateForAudioSampleRate_mediaSelectionOption_operatorType_(
        sampleRate: f64,
        mediaSelectionOption: AVMediaSelectionOption,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForAudioSampleRate : sampleRate, mediaSelectionOption : mediaSelectionOption, operatorType : operatorType)
    }
    unsafe fn predicateForChannelCount_operatorType_(
        channelCount: NSInteger,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForChannelCount : channelCount, operatorType : operatorType)
    }
    unsafe fn predicateForBinauralAudio_(isBinauralAudio: BOOL) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForBinauralAudio : isBinauralAudio)
    }
    unsafe fn predicateForImmersiveAudio_(isImmersiveAudio: BOOL) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForImmersiveAudio : isImmersiveAudio)
    }
    unsafe fn predicateForDownmixAudio_(isDownmixAudio: BOOL) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForDownmixAudio : isDownmixAudio)
    }
    unsafe fn predicateForAudioSampleRate_operatorType_(
        sampleRate: f64,
        operatorType: NSPredicateOperatorType,
    ) -> NSPredicate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetVariantQualifier").unwrap(), predicateForAudioSampleRate : sampleRate, operatorType : operatorType)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDisplayCriteria(pub id);
impl std::ops::Deref for AVDisplayCriteria {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDisplayCriteria {}
impl AVDisplayCriteria {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDisplayCriteria").unwrap(), alloc) })
    }
}
impl IAVDisplayCriteria for AVDisplayCriteria {}
pub trait IAVDisplayCriteria: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAsset(pub id);
impl std::ops::Deref for AVAsset {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAsset {}
impl AVAsset {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAsset").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAsset {}
impl PAVAsynchronousKeyValueLoading for AVAsset {}
impl INSObject for AVAsset {}
impl PNSObject for AVAsset {}
impl std::convert::TryFrom<NSObject> for AVAsset {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAsset, Self::Error> {
        let is_kind_of: bool = unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAsset").unwrap()) };
        if is_kind_of {
            Ok(AVAsset(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAsset")
        }
    }
}
impl IAVAsset for AVAsset {}
pub trait IAVAsset: Sized + std::ops::Deref {
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn preferredRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredRate)
    }
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn preferredDisplayCriteria(&self) -> AVDisplayCriteria
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredDisplayCriteria)
    }
    unsafe fn minimumTimeOffsetFromLive(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minimumTimeOffsetFromLive)
    }
    unsafe fn assetWithURL_(URL: NSURL) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAsset").unwrap(), assetWithURL : URL)
    }
}
impl AVAsset_AVAssetAsynchronousLoading for AVAsset {}
pub trait AVAsset_AVAssetAsynchronousLoading: Sized + std::ops::Deref {
    unsafe fn cancelLoading(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelLoading)
    }
    unsafe fn providesPreciseDurationAndTiming(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, providesPreciseDurationAndTiming)
    }
}
impl AVAsset_AVAssetReferenceRestrictions for AVAsset {}
pub trait AVAsset_AVAssetReferenceRestrictions: Sized + std::ops::Deref {
    unsafe fn referenceRestrictions(&self) -> AVAssetReferenceRestrictions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, referenceRestrictions)
    }
}
pub type AVAssetReferenceRestrictions = NSUInteger;
impl AVAsset_AVAssetTrackInspection for AVAsset {}
pub trait AVAsset_AVAssetTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn trackGroups(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackGroups)
    }
}
impl AVAsset_AVAssetMetadataReading for AVAsset {}
pub trait AVAsset_AVAssetMetadataReading: Sized + std::ops::Deref {
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn loadMetadataForFormat_completionHandler_(
        &self,
        format: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadMetadataForFormat : format, completionHandler : completionHandler)
    }
    unsafe fn creationDate(&self) -> AVMetadataItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, creationDate)
    }
    unsafe fn lyrics(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lyrics)
    }
    unsafe fn commonMetadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, commonMetadata)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn availableMetadataFormats(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMetadataFormats)
    }
}
impl AVAsset_AVAssetChapterInspection for AVAsset {}
pub trait AVAsset_AVAssetChapterInspection: Sized + std::ops::Deref {
    unsafe fn chapterMetadataGroupsWithTitleLocale_containingItemsWithCommonKeys_(
        &self,
        locale: NSLocale,
        commonKeys: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsWithTitleLocale : locale, containingItemsWithCommonKeys : commonKeys)
    }
    unsafe fn loadChapterMetadataGroupsWithTitleLocale_containingItemsWithCommonKeys_completionHandler_(
        &self,
        locale: NSLocale,
        commonKeys: NSArray,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadChapterMetadataGroupsWithTitleLocale : locale, containingItemsWithCommonKeys : commonKeys, completionHandler : completionHandler)
    }
    unsafe fn chapterMetadataGroupsBestMatchingPreferredLanguages_(
        &self,
        preferredLanguages: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsBestMatchingPreferredLanguages : preferredLanguages)
    }
    unsafe fn loadChapterMetadataGroupsBestMatchingPreferredLanguages_completionHandler_(
        &self,
        preferredLanguages: NSArray,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadChapterMetadataGroupsBestMatchingPreferredLanguages : preferredLanguages, completionHandler : completionHandler)
    }
    unsafe fn availableChapterLocales(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableChapterLocales)
    }
}
impl AVAsset_AVAssetMediaSelection for AVAsset {}
pub trait AVAsset_AVAssetMediaSelection: Sized + std::ops::Deref {
    unsafe fn mediaSelectionGroupForMediaCharacteristic_(
        &self,
        mediaCharacteristic: NSString,
    ) -> AVMediaSelectionGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionGroupForMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadMediaSelectionGroupForMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadMediaSelectionGroupForMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
    unsafe fn availableMediaCharacteristicsWithMediaSelectionOptions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMediaCharacteristicsWithMediaSelectionOptions)
    }
    unsafe fn preferredMediaSelection(&self) -> AVMediaSelection
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaSelection)
    }
    unsafe fn allMediaSelections(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allMediaSelections)
    }
}
impl AVAsset_AVAssetProtectedContent for AVAsset {}
pub trait AVAsset_AVAssetProtectedContent: Sized + std::ops::Deref {
    unsafe fn hasProtectedContent(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasProtectedContent)
    }
}
impl AVAsset_AVAssetFragments for AVAsset {}
pub trait AVAsset_AVAssetFragments: Sized + std::ops::Deref {
    unsafe fn canContainFragments(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canContainFragments)
    }
    unsafe fn containsFragments(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, containsFragments)
    }
    unsafe fn overallDurationHint(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, overallDurationHint)
    }
}
impl AVAsset_AVAssetUsability for AVAsset {}
pub trait AVAsset_AVAssetUsability: Sized + std::ops::Deref {
    unsafe fn isPlayable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlayable)
    }
    unsafe fn isExportable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isExportable)
    }
    unsafe fn isReadable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadable)
    }
    unsafe fn isComposable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isComposable)
    }
    unsafe fn isCompatibleWithSavedPhotosAlbum(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCompatibleWithSavedPhotosAlbum)
    }
    unsafe fn isCompatibleWithAirPlayVideo(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCompatibleWithAirPlayVideo)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVURLAsset(pub id);
impl std::ops::Deref for AVURLAsset {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVURLAsset {}
impl AVURLAsset {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), alloc) })
    }
}
impl IAVAsset for AVURLAsset {}
impl PNSCopying for AVURLAsset {}
impl PAVAsynchronousKeyValueLoading for AVURLAsset {}
impl From<AVURLAsset> for AVAsset {
    fn from(child: AVURLAsset) -> AVAsset {
        AVAsset(child.0)
    }
}
impl std::convert::TryFrom<AVAsset> for AVURLAsset {
    type Error = &'static str;
    fn try_from(parent: AVAsset) -> Result<AVURLAsset, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap()) };
        if is_kind_of {
            Ok(AVURLAsset(parent.0))
        } else {
            Err("This AVAsset cannot be downcasted to AVURLAsset")
        }
    }
}
impl INSObject for AVURLAsset {}
impl PNSObject for AVURLAsset {}
impl IAVURLAsset for AVURLAsset {}
pub trait IAVURLAsset: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithURL_options_(&self, URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL, options : options)
    }
    unsafe fn URL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URL)
    }
    unsafe fn httpSessionIdentifier(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, httpSessionIdentifier)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), new)
    }
    unsafe fn audiovisualTypes() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), audiovisualTypes)
    }
    unsafe fn audiovisualMIMETypes() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), audiovisualMIMETypes)
    }
    unsafe fn isPlayableExtendedMIMEType_(extendedMIMEType: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), isPlayableExtendedMIMEType : extendedMIMEType)
    }
    unsafe fn URLAssetWithURL_options_(URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), URLAssetWithURL : URL, options : options)
    }
    unsafe fn audiovisualContentTypes() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVURLAsset").unwrap(), audiovisualContentTypes)
    }
}
impl AVURLAsset_AVURLAssetURLHandling for AVURLAsset {}
pub trait AVURLAsset_AVURLAssetURLHandling: Sized + std::ops::Deref {
    unsafe fn resourceLoader(&self) -> AVAssetResourceLoader
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resourceLoader)
    }
}
impl AVURLAsset_AVURLAssetCache for AVURLAsset {}
pub trait AVURLAsset_AVURLAssetCache: Sized + std::ops::Deref {
    unsafe fn assetCache(&self) -> AVAssetCache
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetCache)
    }
}
impl AVURLAsset_AVAssetCompositionUtility for AVURLAsset {}
pub trait AVURLAsset_AVAssetCompositionUtility: Sized + std::ops::Deref {
    unsafe fn compatibleTrackForCompositionTrack_(
        &self,
        compositionTrack: AVCompositionTrack,
    ) -> AVAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, compatibleTrackForCompositionTrack : compositionTrack)
    }
    unsafe fn findCompatibleTrackForCompositionTrack_completionHandler_(
        &self,
        compositionTrack: AVCompositionTrack,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, findCompatibleTrackForCompositionTrack : compositionTrack, completionHandler : completionHandler)
    }
}
impl AVURLAsset_AVAssetVariantInspection for AVURLAsset {}
pub trait AVURLAsset_AVAssetVariantInspection: Sized + std::ops::Deref {
    unsafe fn variants(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variants)
    }
}
impl AVURLAsset_AVURLAssetNSItemProvider for AVURLAsset {}
pub trait AVURLAsset_AVURLAssetNSItemProvider: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaExtensionProperties(pub id);
impl std::ops::Deref for AVMediaExtensionProperties {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaExtensionProperties {}
impl AVMediaExtensionProperties {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaExtensionProperties").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaExtensionProperties {}
impl INSObject for AVMediaExtensionProperties {}
impl PNSObject for AVMediaExtensionProperties {}
impl std::convert::TryFrom<NSObject> for AVMediaExtensionProperties {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaExtensionProperties, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaExtensionProperties").unwrap()) };
        if is_kind_of {
            Ok(AVMediaExtensionProperties(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaExtensionProperties")
        }
    }
}
impl IAVMediaExtensionProperties for AVMediaExtensionProperties {}
pub trait IAVMediaExtensionProperties: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn extensionIdentifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extensionIdentifier)
    }
    unsafe fn extensionName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extensionName)
    }
    unsafe fn containingBundleName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, containingBundleName)
    }
    unsafe fn extensionURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extensionURL)
    }
    unsafe fn containingBundleURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, containingBundleURL)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaExtensionProperties").unwrap(), new)
    }
}
impl AVURLAsset_AVMediaExtension for AVURLAsset {}
pub trait AVURLAsset_AVMediaExtension: Sized + std::ops::Deref {
    unsafe fn mediaExtensionProperties(&self) -> AVMediaExtensionProperties
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaExtensionProperties)
    }
    unsafe fn sidecarURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sidecarURL)
    }
}
pub trait PAVFragmentMinding: Sized + std::ops::Deref {
    unsafe fn isAssociatedWithFragmentMinder(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAssociatedWithFragmentMinder)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedAsset(pub id);
impl std::ops::Deref for AVFragmentedAsset {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedAsset {}
impl AVFragmentedAsset {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedAsset").unwrap(), alloc) })
    }
}
impl PAVFragmentMinding for AVFragmentedAsset {}
impl IAVURLAsset for AVFragmentedAsset {}
impl From<AVFragmentedAsset> for AVURLAsset {
    fn from(child: AVFragmentedAsset) -> AVURLAsset {
        AVURLAsset(child.0)
    }
}
impl std::convert::TryFrom<AVURLAsset> for AVFragmentedAsset {
    type Error = &'static str;
    fn try_from(parent: AVURLAsset) -> Result<AVFragmentedAsset, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedAsset").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedAsset(parent.0))
        } else {
            Err("This AVURLAsset cannot be downcasted to AVFragmentedAsset")
        }
    }
}
impl IAVAsset for AVFragmentedAsset {}
impl PNSCopying for AVFragmentedAsset {}
impl PAVAsynchronousKeyValueLoading for AVFragmentedAsset {}
impl INSObject for AVFragmentedAsset {}
impl PNSObject for AVFragmentedAsset {}
impl IAVFragmentedAsset for AVFragmentedAsset {}
pub trait IAVFragmentedAsset: Sized + std::ops::Deref {
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn fragmentedAssetWithURL_options_(URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedAsset").unwrap(), fragmentedAssetWithURL : URL, options : options)
    }
}
impl AVFragmentedAsset_AVFragmentedAssetTrackInspection for AVFragmentedAsset {}
pub trait AVFragmentedAsset_AVFragmentedAssetTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVFragmentedAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedAssetMinder(pub id);
impl std::ops::Deref for AVFragmentedAssetMinder {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedAssetMinder {}
impl AVFragmentedAssetMinder {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedAssetMinder").unwrap(), alloc) })
    }
}
impl INSObject for AVFragmentedAssetMinder {}
impl PNSObject for AVFragmentedAssetMinder {}
impl std::convert::TryFrom<NSObject> for AVFragmentedAssetMinder {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVFragmentedAssetMinder, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedAssetMinder").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedAssetMinder(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVFragmentedAssetMinder")
        }
    }
}
impl IAVFragmentedAssetMinder for AVFragmentedAssetMinder {}
pub trait IAVFragmentedAssetMinder: Sized + std::ops::Deref {
    unsafe fn initWithAsset_mindingInterval_(
        &self,
        asset: AVAsset,
        mindingInterval: NSTimeInterval,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset, mindingInterval : mindingInterval)
    }
    unsafe fn addFragmentedAsset_(&self, asset: AVAsset)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addFragmentedAsset : asset)
    }
    unsafe fn removeFragmentedAsset_(&self, asset: AVAsset)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeFragmentedAsset : asset)
    }
    unsafe fn mindingInterval(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mindingInterval)
    }
    unsafe fn setMindingInterval_(&self, mindingInterval: NSTimeInterval)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMindingInterval : mindingInterval)
    }
    unsafe fn assets(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assets)
    }
    unsafe fn fragmentedAssetMinderWithAsset_mindingInterval_(
        asset: AVAsset,
        mindingInterval: NSTimeInterval,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedAssetMinder").unwrap(), fragmentedAssetMinderWithAsset : asset, mindingInterval : mindingInterval)
    }
}
impl AVURLAsset_AVURLAssetContentKeyEligibility for AVURLAsset {}
pub trait AVURLAsset_AVURLAssetContentKeyEligibility: Sized + std::ops::Deref {
    unsafe fn mayRequireContentKeysForMediaDataProcessing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mayRequireContentKeysForMediaDataProcessing)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetCache(pub id);
impl std::ops::Deref for AVAssetCache {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetCache {}
impl AVAssetCache {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetCache").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetCache {}
impl PNSObject for AVAssetCache {}
impl std::convert::TryFrom<NSObject> for AVAssetCache {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetCache, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetCache").unwrap()) };
        if is_kind_of {
            Ok(AVAssetCache(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetCache")
        }
    }
}
impl IAVAssetCache for AVAssetCache {}
pub trait IAVAssetCache: Sized + std::ops::Deref {
    unsafe fn mediaSelectionOptionsInMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionOptionsInMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn isPlayableOffline(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlayableOffline)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetCache").unwrap(), new)
    }
}
impl AVAssetCache_AVAssetCacheCustomMediaSelectionScheme for AVAssetCache {}
pub trait AVAssetCache_AVAssetCacheCustomMediaSelectionScheme: Sized + std::ops::Deref {
    unsafe fn mediaPresentationSettingsForMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaPresentationSettingsForMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn mediaPresentationLanguagesForMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaPresentationLanguagesForMediaSelectionGroup : mediaSelectionGroup)
    }
}
pub type AVAudioTimePitchAlgorithm = NSString;
pub type AVAudioSpatializationFormats = NSUInteger;
pub type AVAssetExportSessionStatus = NSInteger;
pub type AVAssetTrackGroupOutputHandling = NSUInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetExportSession(pub id);
impl std::ops::Deref for AVAssetExportSession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetExportSession {}
impl AVAssetExportSession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetExportSession {}
impl PNSObject for AVAssetExportSession {}
impl std::convert::TryFrom<NSObject> for AVAssetExportSession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetExportSession, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap()) };
        if is_kind_of {
            Ok(AVAssetExportSession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetExportSession")
        }
    }
}
impl IAVAssetExportSession for AVAssetExportSession {}
pub trait IAVAssetExportSession: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAsset_presetName_(&self, asset: AVAsset, presetName: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset, presetName : presetName)
    }
    unsafe fn exportAsynchronouslyWithCompletionHandler_(
        &self,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, exportAsynchronouslyWithCompletionHandler : handler)
    }
    unsafe fn cancelExport(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelExport)
    }
    unsafe fn presetName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, presetName)
    }
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
    unsafe fn outputFileType(&self) -> AVFileType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputFileType)
    }
    unsafe fn setOutputFileType_(&self, outputFileType: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputFileType : outputFileType)
    }
    unsafe fn outputURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputURL)
    }
    unsafe fn setOutputURL_(&self, outputURL: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputURL : outputURL)
    }
    unsafe fn shouldOptimizeForNetworkUse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldOptimizeForNetworkUse)
    }
    unsafe fn setShouldOptimizeForNetworkUse_(&self, shouldOptimizeForNetworkUse: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setShouldOptimizeForNetworkUse : shouldOptimizeForNetworkUse)
    }
    unsafe fn allowsParallelizedExport(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowsParallelizedExport)
    }
    unsafe fn setAllowsParallelizedExport_(&self, allowsParallelizedExport: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAllowsParallelizedExport : allowsParallelizedExport)
    }
    unsafe fn status(&self) -> AVAssetExportSessionStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn progress(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, progress)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), new)
    }
    unsafe fn exportSessionWithAsset_presetName_(
        asset: AVAsset,
        presetName: NSString,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), exportSessionWithAsset : asset, presetName : presetName)
    }
}
impl AVAssetExportSession_AVAssetExportSessionPresets for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionPresets: Sized + std::ops::Deref {
    unsafe fn allExportPresets() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), allExportPresets)
    }
    unsafe fn exportPresetsCompatibleWithAsset_(asset: AVAsset) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), exportPresetsCompatibleWithAsset : asset)
    }
    unsafe fn determineCompatibilityOfExportPreset_withAsset_outputFileType_completionHandler_(
        presetName: NSString,
        asset: AVAsset,
        outputFileType: NSString,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetExportSession").unwrap(), determineCompatibilityOfExportPreset : presetName, withAsset : asset, outputFileType : outputFileType, completionHandler : handler)
    }
}
impl AVAssetExportSession_AVAssetExportSessionFileTypes for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionFileTypes: Sized + std::ops::Deref {
    unsafe fn determineCompatibleFileTypesWithCompletionHandler_(
        &self,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, determineCompatibleFileTypesWithCompletionHandler : handler)
    }
    unsafe fn supportedFileTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedFileTypes)
    }
}
impl AVAssetExportSession_AVAssetExportSessionDurationAndLength for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionDurationAndLength:
    Sized + std::ops::Deref
{
    unsafe fn estimateMaximumDurationWithCompletionHandler_(
        &self,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, estimateMaximumDurationWithCompletionHandler : handler)
    }
    unsafe fn estimateOutputFileLengthWithCompletionHandler_(
        &self,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, estimateOutputFileLengthWithCompletionHandler : handler)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn setTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimeRange : timeRange)
    }
    unsafe fn maxDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxDuration)
    }
    unsafe fn estimatedOutputFileLength(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, estimatedOutputFileLength)
    }
    unsafe fn fileLengthLimit(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, fileLengthLimit)
    }
    unsafe fn setFileLengthLimit_(&self, fileLengthLimit: ::std::os::raw::c_longlong)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFileLengthLimit : fileLengthLimit)
    }
}
impl AVAssetExportSession_AVAssetExportSessionMetadata for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionMetadata: Sized + std::ops::Deref {
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn metadataItemFilter(&self) -> AVMetadataItemFilter
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataItemFilter)
    }
    unsafe fn setMetadataItemFilter_(&self, metadataItemFilter: AVMetadataItemFilter)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadataItemFilter : metadataItemFilter)
    }
}
impl AVAssetExportSession_AVAssetExportSessionMediaProcessing for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionMediaProcessing:
    Sized + std::ops::Deref
{
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn audioMix(&self) -> AVAudioMix
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioMix)
    }
    unsafe fn setAudioMix_(&self, audioMix: AVAudioMix)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioMix : audioMix)
    }
    unsafe fn videoComposition(&self) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoComposition)
    }
    unsafe fn setVideoComposition_(&self, videoComposition: AVVideoComposition)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoComposition : videoComposition)
    }
    unsafe fn customVideoCompositor(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositor)
    }
    unsafe fn audioTrackGroupHandling(&self) -> AVAssetTrackGroupOutputHandling
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTrackGroupHandling)
    }
    unsafe fn setAudioTrackGroupHandling_(
        &self,
        audioTrackGroupHandling: AVAssetTrackGroupOutputHandling,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTrackGroupHandling : audioTrackGroupHandling)
    }
}
impl AVAssetExportSession_AVAssetExportSessionMultipass for AVAssetExportSession {}
pub trait AVAssetExportSession_AVAssetExportSessionMultipass: Sized + std::ops::Deref {
    unsafe fn canPerformMultiplePassesOverSourceMediaData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPerformMultiplePassesOverSourceMediaData)
    }
    unsafe fn setCanPerformMultiplePassesOverSourceMediaData_(
        &self,
        canPerformMultiplePassesOverSourceMediaData: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCanPerformMultiplePassesOverSourceMediaData : canPerformMultiplePassesOverSourceMediaData)
    }
    unsafe fn directoryForTemporaryFiles(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, directoryForTemporaryFiles)
    }
    unsafe fn setDirectoryForTemporaryFiles_(&self, directoryForTemporaryFiles: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDirectoryForTemporaryFiles : directoryForTemporaryFiles)
    }
}
pub type AVAssetImageGeneratorApertureMode = NSString;
pub type AVAssetImageGeneratorDynamicRangePolicy = NSString;
pub type AVAssetImageGeneratorResult = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetImageGenerator(pub id);
impl std::ops::Deref for AVAssetImageGenerator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetImageGenerator {}
impl AVAssetImageGenerator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetImageGenerator").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetImageGenerator {}
impl PNSObject for AVAssetImageGenerator {}
impl std::convert::TryFrom<NSObject> for AVAssetImageGenerator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetImageGenerator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetImageGenerator").unwrap()) };
        if is_kind_of {
            Ok(AVAssetImageGenerator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetImageGenerator")
        }
    }
}
impl IAVAssetImageGenerator for AVAssetImageGenerator {}
pub trait IAVAssetImageGenerator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAsset_(&self, asset: AVAsset) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset)
    }
    unsafe fn copyCGImageAtTime_actualTime_error_(
        &self,
        requestedTime: CMTime,
        actualTime: *mut CMTime,
        outError: *mut NSError,
    ) -> CGImageRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, copyCGImageAtTime : requestedTime, actualTime : actualTime, error : outError)
    }
    unsafe fn generateCGImagesAsynchronouslyForTimes_completionHandler_(
        &self,
        requestedTimes: NSArray,
        handler: AVAssetImageGeneratorCompletionHandler,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, generateCGImagesAsynchronouslyForTimes : requestedTimes, completionHandler : handler)
    }
    unsafe fn generateCGImageAsynchronouslyForTime_completionHandler_(
        &self,
        requestedTime: CMTime,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, generateCGImageAsynchronouslyForTime : requestedTime, completionHandler : handler)
    }
    unsafe fn cancelAllCGImageGeneration(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelAllCGImageGeneration)
    }
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
    unsafe fn appliesPreferredTrackTransform(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, appliesPreferredTrackTransform)
    }
    unsafe fn setAppliesPreferredTrackTransform_(&self, appliesPreferredTrackTransform: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAppliesPreferredTrackTransform : appliesPreferredTrackTransform)
    }
    unsafe fn maximumSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maximumSize)
    }
    unsafe fn setMaximumSize_(&self, maximumSize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaximumSize : maximumSize)
    }
    unsafe fn apertureMode(&self) -> AVAssetImageGeneratorApertureMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, apertureMode)
    }
    unsafe fn setApertureMode_(&self, apertureMode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setApertureMode : apertureMode)
    }
    unsafe fn dynamicRangePolicy(&self) -> AVAssetImageGeneratorDynamicRangePolicy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dynamicRangePolicy)
    }
    unsafe fn setDynamicRangePolicy_(&self, dynamicRangePolicy: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDynamicRangePolicy : dynamicRangePolicy)
    }
    unsafe fn videoComposition(&self) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoComposition)
    }
    unsafe fn setVideoComposition_(&self, videoComposition: AVVideoComposition)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoComposition : videoComposition)
    }
    unsafe fn customVideoCompositor(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositor)
    }
    unsafe fn requestedTimeToleranceBefore(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestedTimeToleranceBefore)
    }
    unsafe fn setRequestedTimeToleranceBefore_(&self, requestedTimeToleranceBefore: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRequestedTimeToleranceBefore : requestedTimeToleranceBefore)
    }
    unsafe fn requestedTimeToleranceAfter(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestedTimeToleranceAfter)
    }
    unsafe fn setRequestedTimeToleranceAfter_(&self, requestedTimeToleranceAfter: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRequestedTimeToleranceAfter : requestedTimeToleranceAfter)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetImageGenerator").unwrap(), new)
    }
    unsafe fn assetImageGeneratorWithAsset_(asset: AVAsset) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetImageGenerator").unwrap(), assetImageGeneratorWithAsset : asset)
    }
}
pub type AVAssetImageGeneratorCompletionHandler = *mut ::std::os::raw::c_void;
pub type AVAssetReaderStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReader(pub id);
impl std::ops::Deref for AVAssetReader {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReader {}
impl AVAssetReader {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReader").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetReader {}
impl PNSObject for AVAssetReader {}
impl std::convert::TryFrom<NSObject> for AVAssetReader {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetReader, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReader").unwrap()) };
        if is_kind_of {
            Ok(AVAssetReader(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetReader")
        }
    }
}
impl IAVAssetReader for AVAssetReader {}
pub trait IAVAssetReader: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAsset_error_(&self, asset: AVAsset, outError: *mut NSError) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset, error : outError)
    }
    unsafe fn canAddOutput_(&self, output: AVAssetReaderOutput) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddOutput : output)
    }
    unsafe fn addOutput_(&self, output: AVAssetReaderOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addOutput : output)
    }
    unsafe fn startReading(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startReading)
    }
    unsafe fn cancelReading(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelReading)
    }
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
    unsafe fn status(&self) -> AVAssetReaderStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn setTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimeRange : timeRange)
    }
    unsafe fn outputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputs)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReader").unwrap(), new)
    }
    unsafe fn assetReaderWithAsset_error_(asset: AVAsset, outError: *mut NSError) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReader").unwrap(), assetReaderWithAsset : asset, error : outError)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataGroup(pub id);
impl std::ops::Deref for AVMetadataGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataGroup {}
impl AVMetadataGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataGroup").unwrap(), alloc) })
    }
}
impl INSObject for AVMetadataGroup {}
impl PNSObject for AVMetadataGroup {}
impl std::convert::TryFrom<NSObject> for AVMetadataGroup {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetadataGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataGroup").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataGroup(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetadataGroup")
        }
    }
}
impl IAVMetadataGroup for AVMetadataGroup {}
pub trait IAVMetadataGroup: Sized + std::ops::Deref {
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
}
impl AVMetadataGroup_AVMetadataGroupIdentification for AVMetadataGroup {}
pub trait AVMetadataGroup_AVMetadataGroupIdentification: Sized + std::ops::Deref {
    unsafe fn classifyingLabel(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, classifyingLabel)
    }
    unsafe fn uniqueID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uniqueID)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVTimedMetadataGroup(pub id);
impl std::ops::Deref for AVTimedMetadataGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVTimedMetadataGroup {}
impl AVTimedMetadataGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVTimedMetadataGroup").unwrap(), alloc) })
    }
}
impl PNSCopying for AVTimedMetadataGroup {}
impl PNSMutableCopying for AVTimedMetadataGroup {}
impl IAVMetadataGroup for AVTimedMetadataGroup {}
impl From<AVTimedMetadataGroup> for AVMetadataGroup {
    fn from(child: AVTimedMetadataGroup) -> AVMetadataGroup {
        AVMetadataGroup(child.0)
    }
}
impl std::convert::TryFrom<AVMetadataGroup> for AVTimedMetadataGroup {
    type Error = &'static str;
    fn try_from(parent: AVMetadataGroup) -> Result<AVTimedMetadataGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVTimedMetadataGroup").unwrap()) };
        if is_kind_of {
            Ok(AVTimedMetadataGroup(parent.0))
        } else {
            Err("This AVMetadataGroup cannot be downcasted to AVTimedMetadataGroup")
        }
    }
}
impl INSObject for AVTimedMetadataGroup {}
impl PNSObject for AVTimedMetadataGroup {}
impl IAVTimedMetadataGroup for AVTimedMetadataGroup {}
pub trait IAVTimedMetadataGroup: Sized + std::ops::Deref {
    unsafe fn initWithItems_timeRange_(
        &self,
        items: NSArray,
        timeRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithItems : items, timeRange : timeRange)
    }
    unsafe fn initWithSampleBuffer_(&self, sampleBuffer: CMSampleBufferRef) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithSampleBuffer : sampleBuffer)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
}
impl AVTimedMetadataGroup_AVTimedMetadataGroupSerializationSupport for AVTimedMetadataGroup {}
pub trait AVTimedMetadataGroup_AVTimedMetadataGroupSerializationSupport:
    Sized + std::ops::Deref
{
    unsafe fn copyFormatDescription(&self) -> CMMetadataFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copyFormatDescription)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableTimedMetadataGroup(pub id);
impl std::ops::Deref for AVMutableTimedMetadataGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableTimedMetadataGroup {}
impl AVMutableTimedMetadataGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableTimedMetadataGroup").unwrap(), alloc) })
    }
}
impl IAVTimedMetadataGroup for AVMutableTimedMetadataGroup {}
impl PNSCopying for AVMutableTimedMetadataGroup {}
impl PNSMutableCopying for AVMutableTimedMetadataGroup {}
impl From<AVMutableTimedMetadataGroup> for AVTimedMetadataGroup {
    fn from(child: AVMutableTimedMetadataGroup) -> AVTimedMetadataGroup {
        AVTimedMetadataGroup(child.0)
    }
}
impl std::convert::TryFrom<AVTimedMetadataGroup> for AVMutableTimedMetadataGroup {
    type Error = &'static str;
    fn try_from(parent: AVTimedMetadataGroup) -> Result<AVMutableTimedMetadataGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableTimedMetadataGroup").unwrap()) };
        if is_kind_of {
            Ok(AVMutableTimedMetadataGroup(parent.0))
        } else {
            Err("This AVTimedMetadataGroup cannot be downcasted to AVMutableTimedMetadataGroup")
        }
    }
}
impl IAVMetadataGroup for AVMutableTimedMetadataGroup {}
impl INSObject for AVMutableTimedMetadataGroup {}
impl PNSObject for AVMutableTimedMetadataGroup {}
impl IAVMutableTimedMetadataGroup for AVMutableTimedMetadataGroup {}
pub trait IAVMutableTimedMetadataGroup: Sized + std::ops::Deref {
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn setTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimeRange : timeRange)
    }
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
    unsafe fn setItems_(&self, items: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setItems : items)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDateRangeMetadataGroup(pub id);
impl std::ops::Deref for AVDateRangeMetadataGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDateRangeMetadataGroup {}
impl AVDateRangeMetadataGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDateRangeMetadataGroup").unwrap(), alloc) })
    }
}
impl PNSCopying for AVDateRangeMetadataGroup {}
impl PNSMutableCopying for AVDateRangeMetadataGroup {}
impl IAVMetadataGroup for AVDateRangeMetadataGroup {}
impl std::convert::TryFrom<AVMetadataGroup> for AVDateRangeMetadataGroup {
    type Error = &'static str;
    fn try_from(parent: AVMetadataGroup) -> Result<AVDateRangeMetadataGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDateRangeMetadataGroup").unwrap()) };
        if is_kind_of {
            Ok(AVDateRangeMetadataGroup(parent.0))
        } else {
            Err("This AVMetadataGroup cannot be downcasted to AVDateRangeMetadataGroup")
        }
    }
}
impl INSObject for AVDateRangeMetadataGroup {}
impl PNSObject for AVDateRangeMetadataGroup {}
impl IAVDateRangeMetadataGroup for AVDateRangeMetadataGroup {}
pub trait IAVDateRangeMetadataGroup: Sized + std::ops::Deref {
    unsafe fn initWithItems_startDate_endDate_(
        &self,
        items: NSArray,
        startDate: NSDate,
        endDate: NSDate,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithItems : items, startDate : startDate, endDate : endDate)
    }
    unsafe fn startDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startDate)
    }
    unsafe fn endDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, endDate)
    }
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableDateRangeMetadataGroup(pub id);
impl std::ops::Deref for AVMutableDateRangeMetadataGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableDateRangeMetadataGroup {}
impl AVMutableDateRangeMetadataGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableDateRangeMetadataGroup").unwrap(), alloc) })
    }
}
impl IAVDateRangeMetadataGroup for AVMutableDateRangeMetadataGroup {}
impl PNSCopying for AVMutableDateRangeMetadataGroup {}
impl PNSMutableCopying for AVMutableDateRangeMetadataGroup {}
impl From<AVMutableDateRangeMetadataGroup> for AVDateRangeMetadataGroup {
    fn from(child: AVMutableDateRangeMetadataGroup) -> AVDateRangeMetadataGroup {
        AVDateRangeMetadataGroup(child.0)
    }
}
impl std::convert::TryFrom<AVDateRangeMetadataGroup> for AVMutableDateRangeMetadataGroup {
    type Error = &'static str;
    fn try_from(
        parent: AVDateRangeMetadataGroup,
    ) -> Result<AVMutableDateRangeMetadataGroup, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableDateRangeMetadataGroup").unwrap())
        };
        if is_kind_of {
            Ok(AVMutableDateRangeMetadataGroup(parent.0))
        } else {
            Err ("This AVDateRangeMetadataGroup cannot be downcasted to AVMutableDateRangeMetadataGroup" ,)
        }
    }
}
impl IAVMetadataGroup for AVMutableDateRangeMetadataGroup {}
impl INSObject for AVMutableDateRangeMetadataGroup {}
impl PNSObject for AVMutableDateRangeMetadataGroup {}
impl IAVMutableDateRangeMetadataGroup for AVMutableDateRangeMetadataGroup {}
pub trait IAVMutableDateRangeMetadataGroup: Sized + std::ops::Deref {
    unsafe fn startDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startDate)
    }
    unsafe fn setStartDate_(&self, startDate: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setStartDate : startDate)
    }
    unsafe fn endDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, endDate)
    }
    unsafe fn setEndDate_(&self, endDate: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEndDate : endDate)
    }
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
    unsafe fn setItems_(&self, items: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setItems : items)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSpatialVideoConfiguration(pub id);
impl std::ops::Deref for AVSpatialVideoConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSpatialVideoConfiguration {}
impl AVSpatialVideoConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSpatialVideoConfiguration").unwrap(), alloc) })
    }
}
impl INSObject for AVSpatialVideoConfiguration {}
impl PNSObject for AVSpatialVideoConfiguration {}
impl std::convert::TryFrom<NSObject> for AVSpatialVideoConfiguration {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSpatialVideoConfiguration, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSpatialVideoConfiguration").unwrap()) };
        if is_kind_of {
            Ok(AVSpatialVideoConfiguration(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSpatialVideoConfiguration")
        }
    }
}
impl IAVSpatialVideoConfiguration for AVSpatialVideoConfiguration {}
pub trait IAVSpatialVideoConfiguration: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithFormatDescription_(
        &self,
        formatDescription: CMFormatDescriptionRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithFormatDescription : formatDescription)
    }
    unsafe fn cameraCalibrationDataLensCollection(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraCalibrationDataLensCollection)
    }
    unsafe fn setCameraCalibrationDataLensCollection_(
        &self,
        cameraCalibrationDataLensCollection: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraCalibrationDataLensCollection : cameraCalibrationDataLensCollection)
    }
    unsafe fn horizontalFieldOfView(&self) -> NSNumber
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, horizontalFieldOfView)
    }
    unsafe fn setHorizontalFieldOfView_(&self, horizontalFieldOfView: NSNumber)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setHorizontalFieldOfView : horizontalFieldOfView)
    }
    unsafe fn cameraSystemBaseline(&self) -> NSNumber
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraSystemBaseline)
    }
    unsafe fn setCameraSystemBaseline_(&self, cameraSystemBaseline: NSNumber)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraSystemBaseline : cameraSystemBaseline)
    }
    unsafe fn disparityAdjustment(&self) -> NSNumber
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, disparityAdjustment)
    }
    unsafe fn setDisparityAdjustment_(&self, disparityAdjustment: NSNumber)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDisparityAdjustment : disparityAdjustment)
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVPixelAspectRatio {
    pub horizontalSpacing: NSInteger,
    pub verticalSpacing: NSInteger,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVEdgeWidths {
    pub left: CGFloat,
    pub top: CGFloat,
    pub right: CGFloat,
    pub bottom: CGFloat,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoCompositionRenderContext(pub id);
impl std::ops::Deref for AVVideoCompositionRenderContext {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoCompositionRenderContext {}
impl AVVideoCompositionRenderContext {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionRenderContext").unwrap(), alloc) })
    }
}
impl INSObject for AVVideoCompositionRenderContext {}
impl PNSObject for AVVideoCompositionRenderContext {}
impl std::convert::TryFrom<NSObject> for AVVideoCompositionRenderContext {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoCompositionRenderContext, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoCompositionRenderContext").unwrap())
        };
        if is_kind_of {
            Ok(AVVideoCompositionRenderContext(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoCompositionRenderContext")
        }
    }
}
impl IAVVideoCompositionRenderContext for AVVideoCompositionRenderContext {}
pub trait IAVVideoCompositionRenderContext: Sized + std::ops::Deref {
    unsafe fn newPixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, newPixelBuffer)
    }
    unsafe fn size(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, size)
    }
    unsafe fn renderTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderTransform)
    }
    unsafe fn renderScale(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderScale)
    }
    unsafe fn pixelAspectRatio(&self) -> AVPixelAspectRatio
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelAspectRatio)
    }
    unsafe fn edgeWidths(&self) -> AVEdgeWidths
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, edgeWidths)
    }
    unsafe fn highQualityRendering(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, highQualityRendering)
    }
    unsafe fn videoComposition(&self) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoComposition)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoCompositionRenderHint(pub id);
impl std::ops::Deref for AVVideoCompositionRenderHint {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoCompositionRenderHint {}
impl AVVideoCompositionRenderHint {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionRenderHint").unwrap(), alloc) })
    }
}
impl INSObject for AVVideoCompositionRenderHint {}
impl PNSObject for AVVideoCompositionRenderHint {}
impl std::convert::TryFrom<NSObject> for AVVideoCompositionRenderHint {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoCompositionRenderHint, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoCompositionRenderHint").unwrap()) };
        if is_kind_of {
            Ok(AVVideoCompositionRenderHint(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoCompositionRenderHint")
        }
    }
}
impl IAVVideoCompositionRenderHint for AVVideoCompositionRenderHint {}
pub trait IAVVideoCompositionRenderHint: Sized + std::ops::Deref {
    unsafe fn startCompositionTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startCompositionTime)
    }
    unsafe fn endCompositionTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, endCompositionTime)
    }
}
pub trait PAVVideoCompositing: Sized + std::ops::Deref {
    unsafe fn renderContextChanged_(&self, newRenderContext: AVVideoCompositionRenderContext)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, renderContextChanged : newRenderContext)
    }
    unsafe fn startVideoCompositionRequest_(
        &self,
        asyncVideoCompositionRequest: AVAsynchronousVideoCompositionRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startVideoCompositionRequest : asyncVideoCompositionRequest)
    }
    unsafe fn cancelAllPendingVideoCompositionRequests(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelAllPendingVideoCompositionRequests)
    }
    unsafe fn anticipateRenderingUsingHint_(&self, renderHint: AVVideoCompositionRenderHint)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, anticipateRenderingUsingHint : renderHint)
    }
    unsafe fn prerollForRenderingUsingHint_(&self, renderHint: AVVideoCompositionRenderHint)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, prerollForRenderingUsingHint : renderHint)
    }
    unsafe fn sourcePixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourcePixelBufferAttributes)
    }
    unsafe fn requiredPixelBufferAttributesForRenderContext(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredPixelBufferAttributesForRenderContext)
    }
    unsafe fn supportsWideColorSourceFrames(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportsWideColorSourceFrames)
    }
    unsafe fn supportsHDRSourceFrames(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportsHDRSourceFrames)
    }
    unsafe fn supportsSourceTaggedBuffers(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportsSourceTaggedBuffers)
    }
    unsafe fn canConformColorOfSourceFrames(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canConformColorOfSourceFrames)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAsynchronousVideoCompositionRequest(pub id);
impl std::ops::Deref for AVAsynchronousVideoCompositionRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAsynchronousVideoCompositionRequest {}
impl AVAsynchronousVideoCompositionRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAsynchronousVideoCompositionRequest").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAsynchronousVideoCompositionRequest {}
impl INSObject for AVAsynchronousVideoCompositionRequest {}
impl PNSObject for AVAsynchronousVideoCompositionRequest {}
impl std::convert::TryFrom<NSObject> for AVAsynchronousVideoCompositionRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAsynchronousVideoCompositionRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAsynchronousVideoCompositionRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAsynchronousVideoCompositionRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAsynchronousVideoCompositionRequest")
        }
    }
}
impl IAVAsynchronousVideoCompositionRequest for AVAsynchronousVideoCompositionRequest {}
pub trait IAVAsynchronousVideoCompositionRequest: Sized + std::ops::Deref {
    unsafe fn sourceFrameByTrackID_(&self, trackID: CMPersistentTrackID) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sourceFrameByTrackID : trackID)
    }
    unsafe fn sourceSampleBufferByTrackID_(&self, trackID: CMPersistentTrackID) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sourceSampleBufferByTrackID : trackID)
    }
    unsafe fn sourceTimedMetadataByTrackID_(
        &self,
        trackID: CMPersistentTrackID,
    ) -> AVTimedMetadataGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sourceTimedMetadataByTrackID : trackID)
    }
    unsafe fn finishWithComposedVideoFrame_(&self, composedVideoFrame: CVPixelBufferRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWithComposedVideoFrame : composedVideoFrame)
    }
    unsafe fn finishWithError_(&self, error: NSError)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWithError : error)
    }
    unsafe fn finishCancelledRequest(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, finishCancelledRequest)
    }
    unsafe fn sourceTaggedBufferGroupByTrackID_(
        &self,
        trackID: CMPersistentTrackID,
    ) -> CMTaggedBufferGroupRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sourceTaggedBufferGroupByTrackID : trackID)
    }
    unsafe fn finishWithComposedTaggedBufferGroup_(&self, taggedBufferGroup: CMTaggedBufferGroupRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWithComposedTaggedBufferGroup : taggedBufferGroup)
    }
    unsafe fn attachSpatialVideoConfiguration_toPixelBuffer_(
        &self,
        spatialVideoConfiguration: AVSpatialVideoConfiguration,
        pixelBuffer: CVPixelBufferRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, attachSpatialVideoConfiguration : spatialVideoConfiguration, toPixelBuffer : pixelBuffer)
    }
    unsafe fn renderContext(&self) -> AVVideoCompositionRenderContext
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderContext)
    }
    unsafe fn compositionTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, compositionTime)
    }
    unsafe fn sourceTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceTrackIDs)
    }
    unsafe fn sourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceSampleDataTrackIDs)
    }
    unsafe fn videoCompositionInstruction(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoCompositionInstruction)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAsynchronousCIImageFilteringRequest(pub id);
impl std::ops::Deref for AVAsynchronousCIImageFilteringRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAsynchronousCIImageFilteringRequest {}
impl AVAsynchronousCIImageFilteringRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAsynchronousCIImageFilteringRequest").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAsynchronousCIImageFilteringRequest {}
impl INSObject for AVAsynchronousCIImageFilteringRequest {}
impl PNSObject for AVAsynchronousCIImageFilteringRequest {}
impl std::convert::TryFrom<NSObject> for AVAsynchronousCIImageFilteringRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAsynchronousCIImageFilteringRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAsynchronousCIImageFilteringRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAsynchronousCIImageFilteringRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAsynchronousCIImageFilteringRequest")
        }
    }
}
impl IAVAsynchronousCIImageFilteringRequest for AVAsynchronousCIImageFilteringRequest {}
pub trait IAVAsynchronousCIImageFilteringRequest: Sized + std::ops::Deref {
    unsafe fn finishWithImage_context_(&self, filteredImage: CIImage, context: CIContext)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWithImage : filteredImage, context : context)
    }
    unsafe fn finishWithError_(&self, error: NSError)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWithError : error)
    }
    unsafe fn renderSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderSize)
    }
    unsafe fn compositionTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, compositionTime)
    }
    unsafe fn sourceImage(&self) -> CIImage
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceImage)
    }
}
pub trait PAVVideoCompositionInstruction: Sized + std::ops::Deref {
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn enablePostProcessing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enablePostProcessing)
    }
    unsafe fn containsTweening(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, containsTweening)
    }
    unsafe fn requiredSourceTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredSourceTrackIDs)
    }
    unsafe fn passthroughTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, passthroughTrackID)
    }
    unsafe fn requiredSourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredSourceSampleDataTrackIDs)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoComposition(pub id);
impl std::ops::Deref for AVVideoComposition {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoComposition {}
impl AVVideoComposition {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), alloc) })
    }
}
impl PNSCopying for AVVideoComposition {}
impl PNSMutableCopying for AVVideoComposition {}
impl INSObject for AVVideoComposition {}
impl PNSObject for AVVideoComposition {}
impl std::convert::TryFrom<NSObject> for AVVideoComposition {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoComposition, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap()) };
        if is_kind_of {
            Ok(AVVideoComposition(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoComposition")
        }
    }
}
impl IAVVideoComposition for AVVideoComposition {}
pub trait IAVVideoComposition: Sized + std::ops::Deref {
    unsafe fn customVideoCompositorClass(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositorClass)
    }
    unsafe fn frameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, frameDuration)
    }
    unsafe fn sourceTrackIDForFrameTiming(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceTrackIDForFrameTiming)
    }
    unsafe fn renderSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderSize)
    }
    unsafe fn renderScale(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderScale)
    }
    unsafe fn instructions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, instructions)
    }
    unsafe fn animationTool(&self) -> AVVideoCompositionCoreAnimationTool
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, animationTool)
    }
    unsafe fn sourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceSampleDataTrackIDs)
    }
    unsafe fn outputBufferDescription(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputBufferDescription)
    }
    unsafe fn spatialVideoConfigurations(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, spatialVideoConfigurations)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_(asset: AVAsset) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_completionHandler_(
        asset: AVAsset,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset, completionHandler : completionHandler)
    }
    unsafe fn videoCompositionWithVideoComposition_(
        videoComposition: AVVideoComposition,
    ) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), videoCompositionWithVideoComposition : videoComposition)
    }
}
pub type AVVideoCompositionPerFrameHDRDisplayMetadataPolicy = NSString;
impl AVVideoComposition_AVVideoCompositionColorimetery for AVVideoComposition {}
pub trait AVVideoComposition_AVVideoCompositionColorimetery: Sized + std::ops::Deref {
    unsafe fn colorPrimaries(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorPrimaries)
    }
    unsafe fn colorYCbCrMatrix(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorYCbCrMatrix)
    }
    unsafe fn colorTransferFunction(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorTransferFunction)
    }
    unsafe fn perFrameHDRDisplayMetadataPolicy(
        &self,
    ) -> AVVideoCompositionPerFrameHDRDisplayMetadataPolicy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, perFrameHDRDisplayMetadataPolicy)
    }
}
impl AVVideoComposition_AVVideoCompositionFiltering for AVVideoComposition {}
pub trait AVVideoComposition_AVVideoCompositionFiltering: Sized + std::ops::Deref {
    unsafe fn videoCompositionWithAsset_applyingCIFiltersWithHandler_(
        asset: AVAsset,
        applier: *mut ::std::os::raw::c_void,
    ) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), videoCompositionWithAsset : asset, applyingCIFiltersWithHandler : applier)
    }
    unsafe fn videoCompositionWithAsset_applyingCIFiltersWithHandler_completionHandler_(
        asset: AVAsset,
        applier: *mut ::std::os::raw::c_void,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoComposition").unwrap(), videoCompositionWithAsset : asset, applyingCIFiltersWithHandler : applier, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableVideoComposition(pub id);
impl std::ops::Deref for AVMutableVideoComposition {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableVideoComposition {}
impl AVMutableVideoComposition {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), alloc) })
    }
}
impl IAVVideoComposition for AVMutableVideoComposition {}
impl PNSCopying for AVMutableVideoComposition {}
impl PNSMutableCopying for AVMutableVideoComposition {}
impl From<AVMutableVideoComposition> for AVVideoComposition {
    fn from(child: AVMutableVideoComposition) -> AVVideoComposition {
        AVVideoComposition(child.0)
    }
}
impl std::convert::TryFrom<AVVideoComposition> for AVMutableVideoComposition {
    type Error = &'static str;
    fn try_from(parent: AVVideoComposition) -> Result<AVMutableVideoComposition, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap()) };
        if is_kind_of {
            Ok(AVMutableVideoComposition(parent.0))
        } else {
            Err("This AVVideoComposition cannot be downcasted to AVMutableVideoComposition")
        }
    }
}
impl INSObject for AVMutableVideoComposition {}
impl PNSObject for AVMutableVideoComposition {}
impl IAVMutableVideoComposition for AVMutableVideoComposition {}
pub trait IAVMutableVideoComposition: Sized + std::ops::Deref {
    unsafe fn customVideoCompositorClass(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositorClass)
    }
    unsafe fn setCustomVideoCompositorClass_(&self, customVideoCompositorClass: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCustomVideoCompositorClass : customVideoCompositorClass)
    }
    unsafe fn frameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, frameDuration)
    }
    unsafe fn setFrameDuration_(&self, frameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFrameDuration : frameDuration)
    }
    unsafe fn sourceTrackIDForFrameTiming(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceTrackIDForFrameTiming)
    }
    unsafe fn setSourceTrackIDForFrameTiming_(
        &self,
        sourceTrackIDForFrameTiming: CMPersistentTrackID,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceTrackIDForFrameTiming : sourceTrackIDForFrameTiming)
    }
    unsafe fn renderSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderSize)
    }
    unsafe fn setRenderSize_(&self, renderSize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRenderSize : renderSize)
    }
    unsafe fn renderScale(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderScale)
    }
    unsafe fn setRenderScale_(&self, renderScale: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRenderScale : renderScale)
    }
    unsafe fn instructions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, instructions)
    }
    unsafe fn setInstructions_(&self, instructions: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInstructions : instructions)
    }
    unsafe fn animationTool(&self) -> AVVideoCompositionCoreAnimationTool
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, animationTool)
    }
    unsafe fn setAnimationTool_(&self, animationTool: AVVideoCompositionCoreAnimationTool)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAnimationTool : animationTool)
    }
    unsafe fn sourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceSampleDataTrackIDs)
    }
    unsafe fn setSourceSampleDataTrackIDs_(&self, sourceSampleDataTrackIDs: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceSampleDataTrackIDs : sourceSampleDataTrackIDs)
    }
    unsafe fn outputBufferDescription(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputBufferDescription)
    }
    unsafe fn setOutputBufferDescription_(&self, outputBufferDescription: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputBufferDescription : outputBufferDescription)
    }
    unsafe fn videoComposition() -> AVMutableVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoComposition)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_(asset: AVAsset) -> AVMutableVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_completionHandler_(
        asset: AVAsset,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset, completionHandler : completionHandler)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_prototypeInstruction_(
        asset: AVAsset,
        prototypeInstruction: AVVideoCompositionInstruction,
    ) -> AVMutableVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset, prototypeInstruction : prototypeInstruction)
    }
    unsafe fn videoCompositionWithPropertiesOfAsset_prototypeInstruction_completionHandler_(
        asset: AVAsset,
        prototypeInstruction: AVVideoCompositionInstruction,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithPropertiesOfAsset : asset, prototypeInstruction : prototypeInstruction, completionHandler : completionHandler)
    }
}
impl AVMutableVideoComposition_AVMutableVideoCompositionColorimetery for AVMutableVideoComposition {}
pub trait AVMutableVideoComposition_AVMutableVideoCompositionColorimetery:
    Sized + std::ops::Deref
{
    unsafe fn colorPrimaries(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorPrimaries)
    }
    unsafe fn setColorPrimaries_(&self, colorPrimaries: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setColorPrimaries : colorPrimaries)
    }
    unsafe fn colorYCbCrMatrix(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorYCbCrMatrix)
    }
    unsafe fn setColorYCbCrMatrix_(&self, colorYCbCrMatrix: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setColorYCbCrMatrix : colorYCbCrMatrix)
    }
    unsafe fn colorTransferFunction(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, colorTransferFunction)
    }
    unsafe fn setColorTransferFunction_(&self, colorTransferFunction: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setColorTransferFunction : colorTransferFunction)
    }
    unsafe fn perFrameHDRDisplayMetadataPolicy(
        &self,
    ) -> AVVideoCompositionPerFrameHDRDisplayMetadataPolicy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, perFrameHDRDisplayMetadataPolicy)
    }
    unsafe fn setPerFrameHDRDisplayMetadataPolicy_(
        &self,
        perFrameHDRDisplayMetadataPolicy: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPerFrameHDRDisplayMetadataPolicy : perFrameHDRDisplayMetadataPolicy)
    }
}
impl AVMutableVideoComposition_AVMutableVideoCompositionFiltering for AVMutableVideoComposition {}
pub trait AVMutableVideoComposition_AVMutableVideoCompositionFiltering:
    Sized + std::ops::Deref
{
    unsafe fn videoCompositionWithAsset_applyingCIFiltersWithHandler_(
        asset: AVAsset,
        applier: *mut ::std::os::raw::c_void,
    ) -> AVMutableVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithAsset : asset, applyingCIFiltersWithHandler : applier)
    }
    unsafe fn videoCompositionWithAsset_applyingCIFiltersWithHandler_completionHandler_(
        asset: AVAsset,
        applier: *mut ::std::os::raw::c_void,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoComposition").unwrap(), videoCompositionWithAsset : asset, applyingCIFiltersWithHandler : applier, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoCompositionInstruction(pub id);
impl std::ops::Deref for AVVideoCompositionInstruction {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoCompositionInstruction {}
impl AVVideoCompositionInstruction {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionInstruction").unwrap(), alloc) })
    }
}
impl PNSSecureCoding for AVVideoCompositionInstruction {}
impl PNSCopying for AVVideoCompositionInstruction {}
impl PNSMutableCopying for AVVideoCompositionInstruction {}
impl PAVVideoCompositionInstruction for AVVideoCompositionInstruction {}
impl INSObject for AVVideoCompositionInstruction {}
impl PNSObject for AVVideoCompositionInstruction {}
impl std::convert::TryFrom<NSObject> for AVVideoCompositionInstruction {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoCompositionInstruction, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoCompositionInstruction").unwrap())
        };
        if is_kind_of {
            Ok(AVVideoCompositionInstruction(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoCompositionInstruction")
        }
    }
}
impl IAVVideoCompositionInstruction for AVVideoCompositionInstruction {}
pub trait IAVVideoCompositionInstruction: Sized + std::ops::Deref {
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn backgroundColor(&self) -> CGColorRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, backgroundColor)
    }
    unsafe fn layerInstructions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, layerInstructions)
    }
    unsafe fn enablePostProcessing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enablePostProcessing)
    }
    unsafe fn requiredSourceTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredSourceTrackIDs)
    }
    unsafe fn passthroughTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, passthroughTrackID)
    }
    unsafe fn requiredSourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredSourceSampleDataTrackIDs)
    }
    unsafe fn videoCompositionInstructionWithInstruction_(
        instruction: AVVideoCompositionInstruction,
    ) -> AVVideoCompositionInstruction
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionInstruction").unwrap(), videoCompositionInstructionWithInstruction : instruction)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableVideoCompositionInstruction(pub id);
impl std::ops::Deref for AVMutableVideoCompositionInstruction {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableVideoCompositionInstruction {}
impl AVMutableVideoCompositionInstruction {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionInstruction").unwrap(), alloc) })
    }
}
impl IAVVideoCompositionInstruction for AVMutableVideoCompositionInstruction {}
impl PNSSecureCoding for AVMutableVideoCompositionInstruction {}
impl PNSCopying for AVMutableVideoCompositionInstruction {}
impl PNSMutableCopying for AVMutableVideoCompositionInstruction {}
impl PAVVideoCompositionInstruction for AVMutableVideoCompositionInstruction {}
impl From<AVMutableVideoCompositionInstruction> for AVVideoCompositionInstruction {
    fn from(child: AVMutableVideoCompositionInstruction) -> AVVideoCompositionInstruction {
        AVVideoCompositionInstruction(child.0)
    }
}
impl std::convert::TryFrom<AVVideoCompositionInstruction> for AVMutableVideoCompositionInstruction {
    type Error = &'static str;
    fn try_from(
        parent: AVVideoCompositionInstruction,
    ) -> Result<AVMutableVideoCompositionInstruction, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionInstruction").unwrap())
        };
        if is_kind_of {
            Ok(AVMutableVideoCompositionInstruction(parent.0))
        } else {
            Err ("This AVVideoCompositionInstruction cannot be downcasted to AVMutableVideoCompositionInstruction" ,)
        }
    }
}
impl INSObject for AVMutableVideoCompositionInstruction {}
impl PNSObject for AVMutableVideoCompositionInstruction {}
impl IAVMutableVideoCompositionInstruction for AVMutableVideoCompositionInstruction {}
pub trait IAVMutableVideoCompositionInstruction: Sized + std::ops::Deref {
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn setTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimeRange : timeRange)
    }
    unsafe fn backgroundColor(&self) -> CGColorRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, backgroundColor)
    }
    unsafe fn setBackgroundColor_(&self, backgroundColor: CGColorRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setBackgroundColor : backgroundColor)
    }
    unsafe fn layerInstructions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, layerInstructions)
    }
    unsafe fn setLayerInstructions_(&self, layerInstructions: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLayerInstructions : layerInstructions)
    }
    unsafe fn enablePostProcessing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enablePostProcessing)
    }
    unsafe fn setEnablePostProcessing_(&self, enablePostProcessing: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnablePostProcessing : enablePostProcessing)
    }
    unsafe fn requiredSourceSampleDataTrackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredSourceSampleDataTrackIDs)
    }
    unsafe fn setRequiredSourceSampleDataTrackIDs_(&self, requiredSourceSampleDataTrackIDs: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRequiredSourceSampleDataTrackIDs : requiredSourceSampleDataTrackIDs)
    }
    unsafe fn videoCompositionInstruction() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionInstruction").unwrap(), videoCompositionInstruction)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoCompositionLayerInstruction(pub id);
impl std::ops::Deref for AVVideoCompositionLayerInstruction {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoCompositionLayerInstruction {}
impl AVVideoCompositionLayerInstruction {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionLayerInstruction").unwrap(), alloc) })
    }
}
impl PNSSecureCoding for AVVideoCompositionLayerInstruction {}
impl PNSCopying for AVVideoCompositionLayerInstruction {}
impl PNSMutableCopying for AVVideoCompositionLayerInstruction {}
impl INSObject for AVVideoCompositionLayerInstruction {}
impl PNSObject for AVVideoCompositionLayerInstruction {}
impl std::convert::TryFrom<NSObject> for AVVideoCompositionLayerInstruction {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoCompositionLayerInstruction, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoCompositionLayerInstruction").unwrap())
        };
        if is_kind_of {
            Ok(AVVideoCompositionLayerInstruction(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoCompositionLayerInstruction")
        }
    }
}
impl IAVVideoCompositionLayerInstruction for AVVideoCompositionLayerInstruction {}
pub trait IAVVideoCompositionLayerInstruction: Sized + std::ops::Deref {
    unsafe fn getTransformRampForTime_startTransform_endTransform_timeRange_(
        &self,
        time: CMTime,
        startTransform: *mut CGAffineTransform,
        endTransform: *mut CGAffineTransform,
        timeRange: *mut CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, getTransformRampForTime : time, startTransform : startTransform, endTransform : endTransform, timeRange : timeRange)
    }
    unsafe fn getOpacityRampForTime_startOpacity_endOpacity_timeRange_(
        &self,
        time: CMTime,
        startOpacity: *mut f32,
        endOpacity: *mut f32,
        timeRange: *mut CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, getOpacityRampForTime : time, startOpacity : startOpacity, endOpacity : endOpacity, timeRange : timeRange)
    }
    unsafe fn getCropRectangleRampForTime_startCropRectangle_endCropRectangle_timeRange_(
        &self,
        time: CMTime,
        startCropRectangle: *mut CGRect,
        endCropRectangle: *mut CGRect,
        timeRange: *mut CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, getCropRectangleRampForTime : time, startCropRectangle : startCropRectangle, endCropRectangle : endCropRectangle, timeRange : timeRange)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn videoCompositionLayerInstructionWithLayerInstruction_(
        instruction: AVVideoCompositionLayerInstruction,
    ) -> AVVideoCompositionLayerInstruction
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionLayerInstruction").unwrap(), videoCompositionLayerInstructionWithLayerInstruction : instruction)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableVideoCompositionLayerInstruction(pub id);
impl std::ops::Deref for AVMutableVideoCompositionLayerInstruction {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableVideoCompositionLayerInstruction {}
impl AVMutableVideoCompositionLayerInstruction {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionLayerInstruction").unwrap(), alloc) })
    }
}
impl IAVVideoCompositionLayerInstruction for AVMutableVideoCompositionLayerInstruction {}
impl PNSSecureCoding for AVMutableVideoCompositionLayerInstruction {}
impl PNSCopying for AVMutableVideoCompositionLayerInstruction {}
impl PNSMutableCopying for AVMutableVideoCompositionLayerInstruction {}
impl From<AVMutableVideoCompositionLayerInstruction> for AVVideoCompositionLayerInstruction {
    fn from(
        child: AVMutableVideoCompositionLayerInstruction,
    ) -> AVVideoCompositionLayerInstruction {
        AVVideoCompositionLayerInstruction(child.0)
    }
}
impl std::convert::TryFrom<AVVideoCompositionLayerInstruction>
    for AVMutableVideoCompositionLayerInstruction
{
    type Error = &'static str;
    fn try_from(
        parent: AVVideoCompositionLayerInstruction,
    ) -> Result<AVMutableVideoCompositionLayerInstruction, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionLayerInstruction").unwrap())
        };
        if is_kind_of {
            Ok(AVMutableVideoCompositionLayerInstruction(parent.0))
        } else {
            Err ("This AVVideoCompositionLayerInstruction cannot be downcasted to AVMutableVideoCompositionLayerInstruction" ,)
        }
    }
}
impl INSObject for AVMutableVideoCompositionLayerInstruction {}
impl PNSObject for AVMutableVideoCompositionLayerInstruction {}
impl IAVMutableVideoCompositionLayerInstruction for AVMutableVideoCompositionLayerInstruction {}
pub trait IAVMutableVideoCompositionLayerInstruction: Sized + std::ops::Deref {
    unsafe fn setTransformRampFromStartTransform_toEndTransform_timeRange_(
        &self,
        startTransform: CGAffineTransform,
        endTransform: CGAffineTransform,
        timeRange: CMTimeRange,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTransformRampFromStartTransform : startTransform, toEndTransform : endTransform, timeRange : timeRange)
    }
    unsafe fn setTransform_atTime_(&self, transform: CGAffineTransform, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTransform : transform, atTime : time)
    }
    unsafe fn setOpacityRampFromStartOpacity_toEndOpacity_timeRange_(
        &self,
        startOpacity: f32,
        endOpacity: f32,
        timeRange: CMTimeRange,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOpacityRampFromStartOpacity : startOpacity, toEndOpacity : endOpacity, timeRange : timeRange)
    }
    unsafe fn setOpacity_atTime_(&self, opacity: f32, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOpacity : opacity, atTime : time)
    }
    unsafe fn setCropRectangleRampFromStartCropRectangle_toEndCropRectangle_timeRange_(
        &self,
        startCropRectangle: CGRect,
        endCropRectangle: CGRect,
        timeRange: CMTimeRange,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCropRectangleRampFromStartCropRectangle : startCropRectangle, toEndCropRectangle : endCropRectangle, timeRange : timeRange)
    }
    unsafe fn setCropRectangle_atTime_(&self, cropRectangle: CGRect, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCropRectangle : cropRectangle, atTime : time)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn setTrackID_(&self, trackID: CMPersistentTrackID)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTrackID : trackID)
    }
    unsafe fn videoCompositionLayerInstructionWithAssetTrack_(track: AVAssetTrack) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionLayerInstruction").unwrap(), videoCompositionLayerInstructionWithAssetTrack : track)
    }
    unsafe fn videoCompositionLayerInstruction() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableVideoCompositionLayerInstruction").unwrap(), videoCompositionLayerInstruction)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoCompositionCoreAnimationTool(pub id);
impl std::ops::Deref for AVVideoCompositionCoreAnimationTool {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoCompositionCoreAnimationTool {}
impl AVVideoCompositionCoreAnimationTool {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionCoreAnimationTool").unwrap(), alloc) })
    }
}
impl INSObject for AVVideoCompositionCoreAnimationTool {}
impl PNSObject for AVVideoCompositionCoreAnimationTool {}
impl std::convert::TryFrom<NSObject> for AVVideoCompositionCoreAnimationTool {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoCompositionCoreAnimationTool, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoCompositionCoreAnimationTool").unwrap())
        };
        if is_kind_of {
            Ok(AVVideoCompositionCoreAnimationTool(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoCompositionCoreAnimationTool")
        }
    }
}
impl IAVVideoCompositionCoreAnimationTool for AVVideoCompositionCoreAnimationTool {}
pub trait IAVVideoCompositionCoreAnimationTool: Sized + std::ops::Deref {
    unsafe fn videoCompositionCoreAnimationToolWithAdditionalLayer_asTrackID_(
        layer: CALayer,
        trackID: CMPersistentTrackID,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionCoreAnimationTool").unwrap(), videoCompositionCoreAnimationToolWithAdditionalLayer : layer, asTrackID : trackID)
    }
    unsafe fn videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer_inLayer_(
        videoLayer: CALayer,
        animationLayer: CALayer,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionCoreAnimationTool").unwrap(), videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer : videoLayer, inLayer : animationLayer)
    }
    unsafe fn videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayers_inLayer_(
        videoLayers: NSArray,
        animationLayer: CALayer,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoCompositionCoreAnimationTool").unwrap(), videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayers : videoLayers, inLayer : animationLayer)
    }
}
impl AVAsset_AVAssetVideoCompositionUtility for AVAsset {}
pub trait AVAsset_AVAssetVideoCompositionUtility: Sized + std::ops::Deref {
    unsafe fn unusedTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unusedTrackID)
    }
    unsafe fn findUnusedTrackIDWithCompletionHandler_(
        &self,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, findUnusedTrackIDWithCompletionHandler : completionHandler)
    }
}
impl AVVideoComposition_AVVideoCompositionValidation for AVVideoComposition {}
pub trait AVVideoComposition_AVVideoCompositionValidation: Sized + std::ops::Deref {
    unsafe fn isValidForAsset_timeRange_validationDelegate_(
        &self,
        asset: AVAsset,
        timeRange: CMTimeRange,
        validationDelegate: *mut u64,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isValidForAsset : asset, timeRange : timeRange, validationDelegate : validationDelegate)
    }
    unsafe fn determineValidityForAsset_timeRange_validationDelegate_completionHandler_(
        &self,
        asset: AVAsset,
        timeRange: CMTimeRange,
        validationDelegate: *mut u64,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, determineValidityForAsset : asset, timeRange : timeRange, validationDelegate : validationDelegate, completionHandler : completionHandler)
    }
    unsafe fn isValidForTracks_assetDuration_timeRange_validationDelegate_(
        &self,
        tracks: NSArray,
        duration: CMTime,
        timeRange: CMTimeRange,
        validationDelegate: *mut u64,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isValidForTracks : tracks, assetDuration : duration, timeRange : timeRange, validationDelegate : validationDelegate)
    }
}
pub trait PAVVideoCompositionValidationHandling: Sized + std::ops::Deref {
    unsafe fn videoComposition_shouldContinueValidatingAfterFindingInvalidValueForKey_(
        &self,
        videoComposition: AVVideoComposition,
        key: NSString,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, videoComposition : videoComposition, shouldContinueValidatingAfterFindingInvalidValueForKey : key)
    }
    unsafe fn videoComposition_shouldContinueValidatingAfterFindingEmptyTimeRange_(
        &self,
        videoComposition: AVVideoComposition,
        timeRange: CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, videoComposition : videoComposition, shouldContinueValidatingAfterFindingEmptyTimeRange : timeRange)
    }
    unsafe fn videoComposition_shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction_(
        &self,
        videoComposition: AVVideoComposition,
        videoCompositionInstruction: *mut u64,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, videoComposition : videoComposition, shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction : videoCompositionInstruction)
    }
    unsafe fn videoComposition_shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction_layerInstruction_asset_(
        &self,
        videoComposition: AVVideoComposition,
        videoCompositionInstruction: *mut u64,
        layerInstruction: AVVideoCompositionLayerInstruction,
        asset: AVAsset,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, videoComposition : videoComposition, shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction : videoCompositionInstruction, layerInstruction : layerInstruction, asset : asset)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderOutput(pub id);
impl std::ops::Deref for AVAssetReaderOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderOutput {}
impl AVAssetReaderOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutput").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetReaderOutput {}
impl PNSObject for AVAssetReaderOutput {}
impl std::convert::TryFrom<NSObject> for AVAssetReaderOutput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetReaderOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderOutput").unwrap()) };
        if is_kind_of {
            Ok(AVAssetReaderOutput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetReaderOutput")
        }
    }
}
impl IAVAssetReaderOutput for AVAssetReaderOutput {}
pub trait IAVAssetReaderOutput: Sized + std::ops::Deref {
    unsafe fn copyNextSampleBuffer(&self) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copyNextSampleBuffer)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn alwaysCopiesSampleData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alwaysCopiesSampleData)
    }
    unsafe fn setAlwaysCopiesSampleData_(&self, alwaysCopiesSampleData: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlwaysCopiesSampleData : alwaysCopiesSampleData)
    }
}
impl AVAssetReaderOutput_AVAssetReaderOutputRandomAccess for AVAssetReaderOutput {}
pub trait AVAssetReaderOutput_AVAssetReaderOutputRandomAccess: Sized + std::ops::Deref {
    unsafe fn resetForReadingTimeRanges_(&self, timeRanges: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resetForReadingTimeRanges : timeRanges)
    }
    unsafe fn markConfigurationAsFinal(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, markConfigurationAsFinal)
    }
    unsafe fn supportsRandomAccess(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportsRandomAccess)
    }
    unsafe fn setSupportsRandomAccess_(&self, supportsRandomAccess: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSupportsRandomAccess : supportsRandomAccess)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderTrackOutput(pub id);
impl std::ops::Deref for AVAssetReaderTrackOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderTrackOutput {}
impl AVAssetReaderTrackOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderTrackOutput").unwrap(), alloc) })
    }
}
impl IAVAssetReaderOutput for AVAssetReaderTrackOutput {}
impl From<AVAssetReaderTrackOutput> for AVAssetReaderOutput {
    fn from(child: AVAssetReaderTrackOutput) -> AVAssetReaderOutput {
        AVAssetReaderOutput(child.0)
    }
}
impl std::convert::TryFrom<AVAssetReaderOutput> for AVAssetReaderTrackOutput {
    type Error = &'static str;
    fn try_from(parent: AVAssetReaderOutput) -> Result<AVAssetReaderTrackOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderTrackOutput").unwrap()) };
        if is_kind_of {
            Ok(AVAssetReaderTrackOutput(parent.0))
        } else {
            Err("This AVAssetReaderOutput cannot be downcasted to AVAssetReaderTrackOutput")
        }
    }
}
impl INSObject for AVAssetReaderTrackOutput {}
impl PNSObject for AVAssetReaderTrackOutput {}
impl IAVAssetReaderTrackOutput for AVAssetReaderTrackOutput {}
pub trait IAVAssetReaderTrackOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithTrack_outputSettings_(
        &self,
        track: AVAssetTrack,
        outputSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTrack : track, outputSettings : outputSettings)
    }
    unsafe fn track(&self) -> AVAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, track)
    }
    unsafe fn outputSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputSettings)
    }
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderTrackOutput").unwrap(), new)
    }
    unsafe fn assetReaderTrackOutputWithTrack_outputSettings_(
        track: AVAssetTrack,
        outputSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderTrackOutput").unwrap(), assetReaderTrackOutputWithTrack : track, outputSettings : outputSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderAudioMixOutput(pub id);
impl std::ops::Deref for AVAssetReaderAudioMixOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderAudioMixOutput {}
impl AVAssetReaderAudioMixOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderAudioMixOutput").unwrap(), alloc) })
    }
}
impl IAVAssetReaderOutput for AVAssetReaderAudioMixOutput {}
impl std::convert::TryFrom<AVAssetReaderOutput> for AVAssetReaderAudioMixOutput {
    type Error = &'static str;
    fn try_from(parent: AVAssetReaderOutput) -> Result<AVAssetReaderAudioMixOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderAudioMixOutput").unwrap()) };
        if is_kind_of {
            Ok(AVAssetReaderAudioMixOutput(parent.0))
        } else {
            Err("This AVAssetReaderOutput cannot be downcasted to AVAssetReaderAudioMixOutput")
        }
    }
}
impl INSObject for AVAssetReaderAudioMixOutput {}
impl PNSObject for AVAssetReaderAudioMixOutput {}
impl IAVAssetReaderAudioMixOutput for AVAssetReaderAudioMixOutput {}
pub trait IAVAssetReaderAudioMixOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAudioTracks_audioSettings_(
        &self,
        audioTracks: NSArray,
        audioSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAudioTracks : audioTracks, audioSettings : audioSettings)
    }
    unsafe fn audioTracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTracks)
    }
    unsafe fn audioSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioSettings)
    }
    unsafe fn audioMix(&self) -> AVAudioMix
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioMix)
    }
    unsafe fn setAudioMix_(&self, audioMix: AVAudioMix)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioMix : audioMix)
    }
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderAudioMixOutput").unwrap(), new)
    }
    unsafe fn assetReaderAudioMixOutputWithAudioTracks_audioSettings_(
        audioTracks: NSArray,
        audioSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderAudioMixOutput").unwrap(), assetReaderAudioMixOutputWithAudioTracks : audioTracks, audioSettings : audioSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderVideoCompositionOutput(pub id);
impl std::ops::Deref for AVAssetReaderVideoCompositionOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderVideoCompositionOutput {}
impl AVAssetReaderVideoCompositionOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderVideoCompositionOutput").unwrap(), alloc) })
    }
}
impl IAVAssetReaderOutput for AVAssetReaderVideoCompositionOutput {}
impl std::convert::TryFrom<AVAssetReaderOutput> for AVAssetReaderVideoCompositionOutput {
    type Error = &'static str;
    fn try_from(
        parent: AVAssetReaderOutput,
    ) -> Result<AVAssetReaderVideoCompositionOutput, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderVideoCompositionOutput").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetReaderVideoCompositionOutput(parent.0))
        } else {
            Err ("This AVAssetReaderOutput cannot be downcasted to AVAssetReaderVideoCompositionOutput" ,)
        }
    }
}
impl INSObject for AVAssetReaderVideoCompositionOutput {}
impl PNSObject for AVAssetReaderVideoCompositionOutput {}
impl IAVAssetReaderVideoCompositionOutput for AVAssetReaderVideoCompositionOutput {}
pub trait IAVAssetReaderVideoCompositionOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithVideoTracks_videoSettings_(
        &self,
        videoTracks: NSArray,
        videoSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithVideoTracks : videoTracks, videoSettings : videoSettings)
    }
    unsafe fn videoTracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoTracks)
    }
    unsafe fn videoSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoSettings)
    }
    unsafe fn videoComposition(&self) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoComposition)
    }
    unsafe fn setVideoComposition_(&self, videoComposition: AVVideoComposition)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoComposition : videoComposition)
    }
    unsafe fn customVideoCompositor(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositor)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderVideoCompositionOutput").unwrap(), new)
    }
    unsafe fn assetReaderVideoCompositionOutputWithVideoTracks_videoSettings_(
        videoTracks: NSArray,
        videoSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderVideoCompositionOutput").unwrap(), assetReaderVideoCompositionOutputWithVideoTracks : videoTracks, videoSettings : videoSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderOutputMetadataAdaptor(pub id);
impl std::ops::Deref for AVAssetReaderOutputMetadataAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderOutputMetadataAdaptor {}
impl AVAssetReaderOutputMetadataAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputMetadataAdaptor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetReaderOutputMetadataAdaptor {}
impl PNSObject for AVAssetReaderOutputMetadataAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetReaderOutputMetadataAdaptor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetReaderOutputMetadataAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderOutputMetadataAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetReaderOutputMetadataAdaptor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetReaderOutputMetadataAdaptor")
        }
    }
}
impl IAVAssetReaderOutputMetadataAdaptor for AVAssetReaderOutputMetadataAdaptor {}
pub trait IAVAssetReaderOutputMetadataAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetReaderTrackOutput_(
        &self,
        trackOutput: AVAssetReaderTrackOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetReaderTrackOutput : trackOutput)
    }
    unsafe fn nextTimedMetadataGroup(&self) -> AVTimedMetadataGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, nextTimedMetadataGroup)
    }
    unsafe fn assetReaderTrackOutput(&self) -> AVAssetReaderTrackOutput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetReaderTrackOutput)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputMetadataAdaptor").unwrap(), new)
    }
    unsafe fn assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput_(
        trackOutput: AVAssetReaderTrackOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputMetadataAdaptor").unwrap(), assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput : trackOutput)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderOutputCaptionAdaptor(pub id);
impl std::ops::Deref for AVAssetReaderOutputCaptionAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderOutputCaptionAdaptor {}
impl AVAssetReaderOutputCaptionAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputCaptionAdaptor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetReaderOutputCaptionAdaptor {}
impl PNSObject for AVAssetReaderOutputCaptionAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetReaderOutputCaptionAdaptor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetReaderOutputCaptionAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderOutputCaptionAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetReaderOutputCaptionAdaptor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetReaderOutputCaptionAdaptor")
        }
    }
}
impl IAVAssetReaderOutputCaptionAdaptor for AVAssetReaderOutputCaptionAdaptor {}
pub trait IAVAssetReaderOutputCaptionAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetReaderTrackOutput_(
        &self,
        trackOutput: AVAssetReaderTrackOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetReaderTrackOutput : trackOutput)
    }
    unsafe fn nextCaptionGroup(&self) -> AVCaptionGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, nextCaptionGroup)
    }
    unsafe fn captionsNotPresentInPreviousGroupsInCaptionGroup_(
        &self,
        captionGroup: AVCaptionGroup,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captionsNotPresentInPreviousGroupsInCaptionGroup : captionGroup)
    }
    unsafe fn assetReaderTrackOutput(&self) -> AVAssetReaderTrackOutput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetReaderTrackOutput)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputCaptionAdaptor").unwrap(), new)
    }
    unsafe fn assetReaderOutputCaptionAdaptorWithAssetReaderTrackOutput_(
        trackOutput: AVAssetReaderTrackOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderOutputCaptionAdaptor").unwrap(), assetReaderOutputCaptionAdaptorWithAssetReaderTrackOutput : trackOutput)
    }
}
impl AVAssetReaderOutputCaptionAdaptor_AVAssetReaderCaptionValidation
    for AVAssetReaderOutputCaptionAdaptor
{
}
pub trait AVAssetReaderOutputCaptionAdaptor_AVAssetReaderCaptionValidation:
    Sized + std::ops::Deref
{
    unsafe fn validationDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, validationDelegate)
    }
    unsafe fn setValidationDelegate_(&self, validationDelegate: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setValidationDelegate : validationDelegate)
    }
}
pub trait PAVAssetReaderCaptionValidationHandling: Sized + std::ops::Deref {
    unsafe fn captionAdaptor_didVendCaption_skippingUnsupportedSourceSyntaxElements_(
        &self,
        adaptor: AVAssetReaderOutputCaptionAdaptor,
        caption: AVCaption,
        syntaxElements: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captionAdaptor : adaptor, didVendCaption : caption, skippingUnsupportedSourceSyntaxElements : syntaxElements)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetReaderSampleReferenceOutput(pub id);
impl std::ops::Deref for AVAssetReaderSampleReferenceOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetReaderSampleReferenceOutput {}
impl AVAssetReaderSampleReferenceOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderSampleReferenceOutput").unwrap(), alloc) })
    }
}
impl IAVAssetReaderOutput for AVAssetReaderSampleReferenceOutput {}
impl std::convert::TryFrom<AVAssetReaderOutput> for AVAssetReaderSampleReferenceOutput {
    type Error = &'static str;
    fn try_from(
        parent: AVAssetReaderOutput,
    ) -> Result<AVAssetReaderSampleReferenceOutput, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetReaderSampleReferenceOutput").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetReaderSampleReferenceOutput(parent.0))
        } else {
            Err ("This AVAssetReaderOutput cannot be downcasted to AVAssetReaderSampleReferenceOutput" ,)
        }
    }
}
impl INSObject for AVAssetReaderSampleReferenceOutput {}
impl PNSObject for AVAssetReaderSampleReferenceOutput {}
impl IAVAssetReaderSampleReferenceOutput for AVAssetReaderSampleReferenceOutput {}
pub trait IAVAssetReaderSampleReferenceOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithTrack_(&self, track: AVAssetTrack) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTrack : track)
    }
    unsafe fn track(&self) -> AVAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, track)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderSampleReferenceOutput").unwrap(), new)
    }
    unsafe fn assetReaderSampleReferenceOutputWithTrack_(track: AVAssetTrack) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetReaderSampleReferenceOutput").unwrap(), assetReaderSampleReferenceOutputWithTrack : track)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceLoader(pub id);
impl std::ops::Deref for AVAssetResourceLoader {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceLoader {}
impl AVAssetResourceLoader {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoader").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetResourceLoader {}
impl PNSObject for AVAssetResourceLoader {}
impl std::convert::TryFrom<NSObject> for AVAssetResourceLoader {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetResourceLoader, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceLoader").unwrap()) };
        if is_kind_of {
            Ok(AVAssetResourceLoader(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetResourceLoader")
        }
    }
}
impl IAVAssetResourceLoader for AVAssetResourceLoader {}
pub trait IAVAssetResourceLoader: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoader").unwrap(), new)
    }
}
pub trait PAVAssetResourceLoaderDelegate: Sized + std::ops::Deref {
    unsafe fn resourceLoader_shouldWaitForLoadingOfRequestedResource_(
        &self,
        resourceLoader: AVAssetResourceLoader,
        loadingRequest: AVAssetResourceLoadingRequest,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resourceLoader : resourceLoader, shouldWaitForLoadingOfRequestedResource : loadingRequest)
    }
    unsafe fn resourceLoader_shouldWaitForRenewalOfRequestedResource_(
        &self,
        resourceLoader: AVAssetResourceLoader,
        renewalRequest: AVAssetResourceRenewalRequest,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resourceLoader : resourceLoader, shouldWaitForRenewalOfRequestedResource : renewalRequest)
    }
    unsafe fn resourceLoader_didCancelLoadingRequest_(
        &self,
        resourceLoader: AVAssetResourceLoader,
        loadingRequest: AVAssetResourceLoadingRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resourceLoader : resourceLoader, didCancelLoadingRequest : loadingRequest)
    }
    unsafe fn resourceLoader_shouldWaitForResponseToAuthenticationChallenge_(
        &self,
        resourceLoader: AVAssetResourceLoader,
        authenticationChallenge: NSURLAuthenticationChallenge,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resourceLoader : resourceLoader, shouldWaitForResponseToAuthenticationChallenge : authenticationChallenge)
    }
    unsafe fn resourceLoader_didCancelAuthenticationChallenge_(
        &self,
        resourceLoader: AVAssetResourceLoader,
        authenticationChallenge: NSURLAuthenticationChallenge,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, resourceLoader : resourceLoader, didCancelAuthenticationChallenge : authenticationChallenge)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceLoadingRequestor(pub id);
impl std::ops::Deref for AVAssetResourceLoadingRequestor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceLoadingRequestor {}
impl AVAssetResourceLoadingRequestor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequestor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetResourceLoadingRequestor {}
impl PNSObject for AVAssetResourceLoadingRequestor {}
impl std::convert::TryFrom<NSObject> for AVAssetResourceLoadingRequestor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetResourceLoadingRequestor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequestor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetResourceLoadingRequestor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetResourceLoadingRequestor")
        }
    }
}
impl IAVAssetResourceLoadingRequestor for AVAssetResourceLoadingRequestor {}
pub trait IAVAssetResourceLoadingRequestor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn providesExpiredSessionReports(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, providesExpiredSessionReports)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequestor").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceLoadingRequest(pub id);
impl std::ops::Deref for AVAssetResourceLoadingRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceLoadingRequest {}
impl AVAssetResourceLoadingRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequest").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetResourceLoadingRequest {}
impl PNSObject for AVAssetResourceLoadingRequest {}
impl std::convert::TryFrom<NSObject> for AVAssetResourceLoadingRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetResourceLoadingRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetResourceLoadingRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetResourceLoadingRequest")
        }
    }
}
impl IAVAssetResourceLoadingRequest for AVAssetResourceLoadingRequest {}
pub trait IAVAssetResourceLoadingRequest: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn finishLoading(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, finishLoading)
    }
    unsafe fn finishLoadingWithError_(&self, error: NSError)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishLoadingWithError : error)
    }
    unsafe fn request(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, request)
    }
    unsafe fn isFinished(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFinished)
    }
    unsafe fn isCancelled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCancelled)
    }
    unsafe fn contentInformationRequest(&self) -> AVAssetResourceLoadingContentInformationRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentInformationRequest)
    }
    unsafe fn dataRequest(&self) -> AVAssetResourceLoadingDataRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataRequest)
    }
    unsafe fn response(&self) -> NSURLResponse
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, response)
    }
    unsafe fn setResponse_(&self, response: NSURLResponse)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setResponse : response)
    }
    unsafe fn redirect(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, redirect)
    }
    unsafe fn setRedirect_(&self, redirect: NSURLRequest)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRedirect : redirect)
    }
    unsafe fn requestor(&self) -> AVAssetResourceLoadingRequestor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestor)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingRequest").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceRenewalRequest(pub id);
impl std::ops::Deref for AVAssetResourceRenewalRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceRenewalRequest {}
impl AVAssetResourceRenewalRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceRenewalRequest").unwrap(), alloc) })
    }
}
impl IAVAssetResourceLoadingRequest for AVAssetResourceRenewalRequest {}
impl From<AVAssetResourceRenewalRequest> for AVAssetResourceLoadingRequest {
    fn from(child: AVAssetResourceRenewalRequest) -> AVAssetResourceLoadingRequest {
        AVAssetResourceLoadingRequest(child.0)
    }
}
impl std::convert::TryFrom<AVAssetResourceLoadingRequest> for AVAssetResourceRenewalRequest {
    type Error = &'static str;
    fn try_from(
        parent: AVAssetResourceLoadingRequest,
    ) -> Result<AVAssetResourceRenewalRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceRenewalRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetResourceRenewalRequest(parent.0))
        } else {
            Err ("This AVAssetResourceLoadingRequest cannot be downcasted to AVAssetResourceRenewalRequest" ,)
        }
    }
}
impl INSObject for AVAssetResourceRenewalRequest {}
impl PNSObject for AVAssetResourceRenewalRequest {}
impl IAVAssetResourceRenewalRequest for AVAssetResourceRenewalRequest {}
pub trait IAVAssetResourceRenewalRequest: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceLoadingContentInformationRequest(pub id);
impl std::ops::Deref for AVAssetResourceLoadingContentInformationRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceLoadingContentInformationRequest {}
impl AVAssetResourceLoadingContentInformationRequest {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingContentInformationRequest").unwrap(), alloc)
        })
    }
}
impl INSObject for AVAssetResourceLoadingContentInformationRequest {}
impl PNSObject for AVAssetResourceLoadingContentInformationRequest {}
impl std::convert::TryFrom<NSObject> for AVAssetResourceLoadingContentInformationRequest {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVAssetResourceLoadingContentInformationRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingContentInformationRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetResourceLoadingContentInformationRequest(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVAssetResourceLoadingContentInformationRequest" ,)
        }
    }
}
impl IAVAssetResourceLoadingContentInformationRequest
    for AVAssetResourceLoadingContentInformationRequest
{
}
pub trait IAVAssetResourceLoadingContentInformationRequest: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn contentType(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentType)
    }
    unsafe fn setContentType_(&self, contentType: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setContentType : contentType)
    }
    unsafe fn allowedContentTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowedContentTypes)
    }
    unsafe fn contentLength(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentLength)
    }
    unsafe fn setContentLength_(&self, contentLength: ::std::os::raw::c_longlong)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setContentLength : contentLength)
    }
    unsafe fn isByteRangeAccessSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isByteRangeAccessSupported)
    }
    unsafe fn setByteRangeAccessSupported_(&self, byteRangeAccessSupported: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setByteRangeAccessSupported : byteRangeAccessSupported)
    }
    unsafe fn renewalDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renewalDate)
    }
    unsafe fn setRenewalDate_(&self, renewalDate: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRenewalDate : renewalDate)
    }
    unsafe fn isEntireLengthAvailableOnDemand(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEntireLengthAvailableOnDemand)
    }
    unsafe fn setEntireLengthAvailableOnDemand_(&self, entireLengthAvailableOnDemand: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEntireLengthAvailableOnDemand : entireLengthAvailableOnDemand)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingContentInformationRequest").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetResourceLoadingDataRequest(pub id);
impl std::ops::Deref for AVAssetResourceLoadingDataRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetResourceLoadingDataRequest {}
impl AVAssetResourceLoadingDataRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingDataRequest").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetResourceLoadingDataRequest {}
impl PNSObject for AVAssetResourceLoadingDataRequest {}
impl std::convert::TryFrom<NSObject> for AVAssetResourceLoadingDataRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetResourceLoadingDataRequest, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingDataRequest").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetResourceLoadingDataRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetResourceLoadingDataRequest")
        }
    }
}
impl IAVAssetResourceLoadingDataRequest for AVAssetResourceLoadingDataRequest {}
pub trait IAVAssetResourceLoadingDataRequest: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn respondWithData_(&self, data: NSData)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, respondWithData : data)
    }
    unsafe fn requestedOffset(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestedOffset)
    }
    unsafe fn requestedLength(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestedLength)
    }
    unsafe fn requestsAllDataToEndOfResource(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestsAllDataToEndOfResource)
    }
    unsafe fn currentOffset(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentOffset)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetResourceLoadingDataRequest").unwrap(), new)
    }
}
impl AVAssetResourceLoader_AVAssetResourceLoaderContentKeySupport for AVAssetResourceLoader {}
pub trait AVAssetResourceLoader_AVAssetResourceLoaderContentKeySupport:
    Sized + std::ops::Deref
{
    unsafe fn preloadsEligibleContentKeys(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preloadsEligibleContentKeys)
    }
    unsafe fn setPreloadsEligibleContentKeys_(&self, preloadsEligibleContentKeys: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreloadsEligibleContentKeys : preloadsEligibleContentKeys)
    }
}
impl AVAssetResourceLoader_AVAssetResourceLoaderCommonMediaClientDataSupport
    for AVAssetResourceLoader
{
}
pub trait AVAssetResourceLoader_AVAssetResourceLoaderCommonMediaClientDataSupport:
    Sized + std::ops::Deref
{
    unsafe fn sendsCommonMediaClientDataAsHTTPHeaders(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sendsCommonMediaClientDataAsHTTPHeaders)
    }
    unsafe fn setSendsCommonMediaClientDataAsHTTPHeaders_(
        &self,
        sendsCommonMediaClientDataAsHTTPHeaders: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSendsCommonMediaClientDataAsHTTPHeaders : sendsCommonMediaClientDataAsHTTPHeaders)
    }
}
impl AVAssetResourceLoadingRequest_AVAssetResourceLoadingRequestContentKeyRequestSupport
    for AVAssetResourceLoadingRequest
{
}
pub trait AVAssetResourceLoadingRequest_AVAssetResourceLoadingRequestContentKeyRequestSupport:
    Sized + std::ops::Deref
{
    unsafe fn streamingContentKeyRequestDataForApp_contentIdentifier_options_error_(
        &self,
        appIdentifier: NSData,
        contentIdentifier: NSData,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, streamingContentKeyRequestDataForApp : appIdentifier, contentIdentifier : contentIdentifier, options : options, error : outError)
    }
    unsafe fn persistentContentKeyFromKeyVendorResponse_options_error_(
        &self,
        keyVendorResponse: NSData,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, persistentContentKeyFromKeyVendorResponse : keyVendorResponse, options : options, error : outError)
    }
}
impl AVAssetResourceLoadingRequest_AVAssetResourceLoadingRequestDeprecated
    for AVAssetResourceLoadingRequest
{
}
pub trait AVAssetResourceLoadingRequest_AVAssetResourceLoadingRequestDeprecated:
    Sized + std::ops::Deref
{
    unsafe fn finishLoadingWithResponse_data_redirect_(
        &self,
        response: NSURLResponse,
        data: NSData,
        redirect: NSURLRequest,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishLoadingWithResponse : response, data : data, redirect : redirect)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetTrackSegment(pub id);
impl std::ops::Deref for AVAssetTrackSegment {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetTrackSegment {}
impl AVAssetTrackSegment {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetTrackSegment").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetTrackSegment {}
impl PNSObject for AVAssetTrackSegment {}
impl std::convert::TryFrom<NSObject> for AVAssetTrackSegment {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetTrackSegment, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetTrackSegment").unwrap()) };
        if is_kind_of {
            Ok(AVAssetTrackSegment(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetTrackSegment")
        }
    }
}
impl IAVAssetTrackSegment for AVAssetTrackSegment {}
pub trait IAVAssetTrackSegment: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn timeMapping(&self) -> CMTimeMapping
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeMapping)
    }
    unsafe fn isEmpty(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEmpty)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetTrackSegment").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetTrack(pub id);
impl std::ops::Deref for AVAssetTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetTrack {}
impl AVAssetTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetTrack").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAssetTrack {}
impl PAVAsynchronousKeyValueLoading for AVAssetTrack {}
impl INSObject for AVAssetTrack {}
impl PNSObject for AVAssetTrack {}
impl std::convert::TryFrom<NSObject> for AVAssetTrack {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetTrack").unwrap()) };
        if is_kind_of {
            Ok(AVAssetTrack(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetTrack")
        }
    }
}
impl IAVAssetTrack for AVAssetTrack {}
pub trait IAVAssetTrack: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetTrack").unwrap(), new)
    }
}
impl AVAssetTrack_AVAssetTrackBasicPropertiesAndCharacteristics for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackBasicPropertiesAndCharacteristics:
    Sized + std::ops::Deref
{
    unsafe fn hasMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn formatDescriptions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formatDescriptions)
    }
    unsafe fn isPlayable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlayable)
    }
    unsafe fn isDecodable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDecodable)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn isSelfContained(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSelfContained)
    }
    unsafe fn totalSampleDataLength(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalSampleDataLength)
    }
}
impl AVAssetTrack_AVAssetTrackTemporalProperties for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackTemporalProperties: Sized + std::ops::Deref {
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn naturalTimeScale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalTimeScale)
    }
    unsafe fn estimatedDataRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, estimatedDataRate)
    }
}
impl AVAssetTrack_AVAssetTrackLanguageProperties for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackLanguageProperties: Sized + std::ops::Deref {
    unsafe fn languageCode(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, languageCode)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
}
impl AVAssetTrack_AVAssetTrackPropertiesForVisualCharacteristic for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackPropertiesForVisualCharacteristic:
    Sized + std::ops::Deref
{
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
}
impl AVAssetTrack_AVAssetTrackPropertiesForAudibleCharacteristic for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackPropertiesForAudibleCharacteristic:
    Sized + std::ops::Deref
{
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn hasAudioSampleDependencies(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasAudioSampleDependencies)
    }
}
impl AVAssetTrack_AVAssetTrackPropertiesForFrameBasedCharacteristic for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackPropertiesForFrameBasedCharacteristic:
    Sized + std::ops::Deref
{
    unsafe fn nominalFrameRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, nominalFrameRate)
    }
    unsafe fn minFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFrameDuration)
    }
    unsafe fn requiresFrameReordering(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiresFrameReordering)
    }
}
impl AVAssetTrack_AVAssetTrackSegments for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackSegments: Sized + std::ops::Deref {
    unsafe fn segmentForTrackTime_(&self, trackTime: CMTime) -> AVAssetTrackSegment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, segmentForTrackTime : trackTime)
    }
    unsafe fn loadSegmentForTrackTime_completionHandler_(
        &self,
        trackTime: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadSegmentForTrackTime : trackTime, completionHandler : completionHandler)
    }
    unsafe fn samplePresentationTimeForTrackTime_(&self, trackTime: CMTime) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, samplePresentationTimeForTrackTime : trackTime)
    }
    unsafe fn loadSamplePresentationTimeForTrackTime_completionHandler_(
        &self,
        trackTime: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadSamplePresentationTimeForTrackTime : trackTime, completionHandler : completionHandler)
    }
    unsafe fn segments(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segments)
    }
}
impl AVAssetTrack_AVAssetTrackMetadataReading for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackMetadataReading: Sized + std::ops::Deref {
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn loadMetadataForFormat_completionHandler_(
        &self,
        format: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadMetadataForFormat : format, completionHandler : completionHandler)
    }
    unsafe fn commonMetadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, commonMetadata)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn availableMetadataFormats(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMetadataFormats)
    }
}
impl AVAssetTrack_AVAssetTrackTrackAssociations for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackTrackAssociations: Sized + std::ops::Deref {
    unsafe fn associatedTracksOfType_(&self, trackAssociationType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, associatedTracksOfType : trackAssociationType)
    }
    unsafe fn loadAssociatedTracksOfType_completionHandler_(
        &self,
        trackAssociationType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadAssociatedTracksOfType : trackAssociationType, completionHandler : completionHandler)
    }
    unsafe fn availableTrackAssociationTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableTrackAssociationTypes)
    }
}
impl AVAssetTrack_AVAssetTrackSampleCursorProvision for AVAssetTrack {}
pub trait AVAssetTrack_AVAssetTrackSampleCursorProvision: Sized + std::ops::Deref {
    unsafe fn makeSampleCursorWithPresentationTimeStamp_(
        &self,
        presentationTimeStamp: CMTime,
    ) -> AVSampleCursor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, makeSampleCursorWithPresentationTimeStamp : presentationTimeStamp)
    }
    unsafe fn makeSampleCursorAtFirstSampleInDecodeOrder(&self) -> AVSampleCursor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, makeSampleCursorAtFirstSampleInDecodeOrder)
    }
    unsafe fn makeSampleCursorAtLastSampleInDecodeOrder(&self) -> AVSampleCursor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, makeSampleCursorAtLastSampleInDecodeOrder)
    }
    unsafe fn canProvideSampleCursors(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canProvideSampleCursors)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedAssetTrack(pub id);
impl std::ops::Deref for AVFragmentedAssetTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedAssetTrack {}
impl AVFragmentedAssetTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedAssetTrack").unwrap(), alloc) })
    }
}
impl IAVAssetTrack for AVFragmentedAssetTrack {}
impl PNSCopying for AVFragmentedAssetTrack {}
impl PAVAsynchronousKeyValueLoading for AVFragmentedAssetTrack {}
impl From<AVFragmentedAssetTrack> for AVAssetTrack {
    fn from(child: AVFragmentedAssetTrack) -> AVAssetTrack {
        AVAssetTrack(child.0)
    }
}
impl std::convert::TryFrom<AVAssetTrack> for AVFragmentedAssetTrack {
    type Error = &'static str;
    fn try_from(parent: AVAssetTrack) -> Result<AVFragmentedAssetTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedAssetTrack").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedAssetTrack(parent.0))
        } else {
            Err("This AVAssetTrack cannot be downcasted to AVFragmentedAssetTrack")
        }
    }
}
impl INSObject for AVFragmentedAssetTrack {}
impl PNSObject for AVFragmentedAssetTrack {}
impl IAVFragmentedAssetTrack for AVFragmentedAssetTrack {}
pub trait IAVFragmentedAssetTrack: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetTrackGroup(pub id);
impl std::ops::Deref for AVAssetTrackGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetTrackGroup {}
impl AVAssetTrackGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetTrackGroup").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAssetTrackGroup {}
impl INSObject for AVAssetTrackGroup {}
impl PNSObject for AVAssetTrackGroup {}
impl std::convert::TryFrom<NSObject> for AVAssetTrackGroup {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetTrackGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetTrackGroup").unwrap()) };
        if is_kind_of {
            Ok(AVAssetTrackGroup(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetTrackGroup")
        }
    }
}
impl IAVAssetTrackGroup for AVAssetTrackGroup {}
pub trait IAVAssetTrackGroup: Sized + std::ops::Deref {
    unsafe fn trackIDs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackIDs)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaSelectionGroup(pub id);
impl std::ops::Deref for AVMediaSelectionGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaSelectionGroup {}
impl AVMediaSelectionGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaSelectionGroup {}
impl INSObject for AVMediaSelectionGroup {}
impl PNSObject for AVMediaSelectionGroup {}
impl std::convert::TryFrom<NSObject> for AVMediaSelectionGroup {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaSelectionGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap()) };
        if is_kind_of {
            Ok(AVMediaSelectionGroup(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaSelectionGroup")
        }
    }
}
impl IAVMediaSelectionGroup for AVMediaSelectionGroup {}
pub trait IAVMediaSelectionGroup: Sized + std::ops::Deref {
    unsafe fn mediaSelectionOptionWithPropertyList_(&self, plist: id) -> AVMediaSelectionOption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionOptionWithPropertyList : plist)
    }
    unsafe fn options(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, options)
    }
    unsafe fn defaultOption(&self) -> AVMediaSelectionOption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultOption)
    }
    unsafe fn allowsEmptySelection(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowsEmptySelection)
    }
}
impl AVMediaSelectionGroup_AVMediaSelectionOptionFiltering for AVMediaSelectionGroup {}
pub trait AVMediaSelectionGroup_AVMediaSelectionOptionFiltering: Sized + std::ops::Deref {
    unsafe fn playableMediaSelectionOptionsFromArray_(mediaSelectionOptions: NSArray) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), playableMediaSelectionOptionsFromArray : mediaSelectionOptions)
    }
    unsafe fn mediaSelectionOptionsFromArray_filteredAndSortedAccordingToPreferredLanguages_(
        mediaSelectionOptions: NSArray,
        preferredLanguages: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), mediaSelectionOptionsFromArray : mediaSelectionOptions, filteredAndSortedAccordingToPreferredLanguages : preferredLanguages)
    }
    unsafe fn mediaSelectionOptionsFromArray_withLocale_(
        mediaSelectionOptions: NSArray,
        locale: NSLocale,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), mediaSelectionOptionsFromArray : mediaSelectionOptions, withLocale : locale)
    }
    unsafe fn mediaSelectionOptionsFromArray_withMediaCharacteristics_(
        mediaSelectionOptions: NSArray,
        mediaCharacteristics: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), mediaSelectionOptionsFromArray : mediaSelectionOptions, withMediaCharacteristics : mediaCharacteristics)
    }
    unsafe fn mediaSelectionOptionsFromArray_withoutMediaCharacteristics_(
        mediaSelectionOptions: NSArray,
        mediaCharacteristics: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionGroup").unwrap(), mediaSelectionOptionsFromArray : mediaSelectionOptions, withoutMediaCharacteristics : mediaCharacteristics)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaSelectionOption(pub id);
impl std::ops::Deref for AVMediaSelectionOption {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaSelectionOption {}
impl AVMediaSelectionOption {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelectionOption").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaSelectionOption {}
impl INSObject for AVMediaSelectionOption {}
impl PNSObject for AVMediaSelectionOption {}
impl std::convert::TryFrom<NSObject> for AVMediaSelectionOption {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaSelectionOption, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaSelectionOption").unwrap()) };
        if is_kind_of {
            Ok(AVMediaSelectionOption(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaSelectionOption")
        }
    }
}
impl IAVMediaSelectionOption for AVMediaSelectionOption {}
pub trait IAVMediaSelectionOption: Sized + std::ops::Deref {
    unsafe fn hasMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn associatedMediaSelectionOptionInMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> AVMediaSelectionOption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, associatedMediaSelectionOptionInMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn propertyList(&self) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, propertyList)
    }
    unsafe fn displayNameWithLocale_(&self, locale: NSLocale) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, displayNameWithLocale : locale)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn mediaSubTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaSubTypes)
    }
    unsafe fn isPlayable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlayable)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn locale(&self) -> NSLocale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, locale)
    }
    unsafe fn commonMetadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, commonMetadata)
    }
    unsafe fn availableMetadataFormats(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMetadataFormats)
    }
    unsafe fn displayName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayName)
    }
}
impl AVMediaSelectionGroup_AVMediaSelectionGroupCustomMediaSelectionScheme
    for AVMediaSelectionGroup
{
}
pub trait AVMediaSelectionGroup_AVMediaSelectionGroupCustomMediaSelectionScheme:
    Sized + std::ops::Deref
{
    unsafe fn customMediaSelectionScheme(&self) -> AVCustomMediaSelectionScheme
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customMediaSelectionScheme)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCustomMediaSelectionScheme(pub id);
impl std::ops::Deref for AVCustomMediaSelectionScheme {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCustomMediaSelectionScheme {}
impl AVCustomMediaSelectionScheme {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCustomMediaSelectionScheme").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCustomMediaSelectionScheme {}
impl INSObject for AVCustomMediaSelectionScheme {}
impl PNSObject for AVCustomMediaSelectionScheme {}
impl std::convert::TryFrom<NSObject> for AVCustomMediaSelectionScheme {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCustomMediaSelectionScheme, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCustomMediaSelectionScheme").unwrap()) };
        if is_kind_of {
            Ok(AVCustomMediaSelectionScheme(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCustomMediaSelectionScheme")
        }
    }
}
impl IAVCustomMediaSelectionScheme for AVCustomMediaSelectionScheme {}
pub trait IAVCustomMediaSelectionScheme: Sized + std::ops::Deref {
    unsafe fn mediaPresentationSettingsForSelector_complementaryToLanguage_settings_(
        &self,
        selector: AVMediaPresentationSelector,
        language: NSString,
        settings: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaPresentationSettingsForSelector : selector, complementaryToLanguage : language, settings : settings)
    }
    unsafe fn shouldOfferLanguageSelection(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldOfferLanguageSelection)
    }
    unsafe fn availableLanguages(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableLanguages)
    }
    unsafe fn selectors(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, selectors)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaPresentationSelector(pub id);
impl std::ops::Deref for AVMediaPresentationSelector {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaPresentationSelector {}
impl AVMediaPresentationSelector {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaPresentationSelector").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaPresentationSelector {}
impl INSObject for AVMediaPresentationSelector {}
impl PNSObject for AVMediaPresentationSelector {}
impl std::convert::TryFrom<NSObject> for AVMediaPresentationSelector {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaPresentationSelector, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaPresentationSelector").unwrap()) };
        if is_kind_of {
            Ok(AVMediaPresentationSelector(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaPresentationSelector")
        }
    }
}
impl IAVMediaPresentationSelector for AVMediaPresentationSelector {}
pub trait IAVMediaPresentationSelector: Sized + std::ops::Deref {
    unsafe fn displayNameForLocaleIdentifier_(&self, localeIdentifier: NSString) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, displayNameForLocaleIdentifier : localeIdentifier)
    }
    unsafe fn identifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn settings(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, settings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaPresentationSetting(pub id);
impl std::ops::Deref for AVMediaPresentationSetting {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaPresentationSetting {}
impl AVMediaPresentationSetting {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaPresentationSetting").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaPresentationSetting {}
impl INSObject for AVMediaPresentationSetting {}
impl PNSObject for AVMediaPresentationSetting {}
impl std::convert::TryFrom<NSObject> for AVMediaPresentationSetting {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaPresentationSetting, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaPresentationSetting").unwrap()) };
        if is_kind_of {
            Ok(AVMediaPresentationSetting(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaPresentationSetting")
        }
    }
}
impl IAVMediaPresentationSetting for AVMediaPresentationSetting {}
pub trait IAVMediaPresentationSetting: Sized + std::ops::Deref {
    unsafe fn displayNameForLocaleIdentifier_(&self, localeIdentifier: NSString) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, displayNameForLocaleIdentifier : localeIdentifier)
    }
    unsafe fn mediaCharacteristic(&self) -> AVMediaCharacteristic
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaCharacteristic)
    }
}
pub type AVAssetSegmentType = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetSegmentReport(pub id);
impl std::ops::Deref for AVAssetSegmentReport {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetSegmentReport {}
impl AVAssetSegmentReport {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentReport").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetSegmentReport {}
impl PNSObject for AVAssetSegmentReport {}
impl std::convert::TryFrom<NSObject> for AVAssetSegmentReport {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetSegmentReport, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetSegmentReport").unwrap()) };
        if is_kind_of {
            Ok(AVAssetSegmentReport(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetSegmentReport")
        }
    }
}
impl IAVAssetSegmentReport for AVAssetSegmentReport {}
pub trait IAVAssetSegmentReport: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn segmentType(&self) -> AVAssetSegmentType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segmentType)
    }
    unsafe fn trackReports(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackReports)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentReport").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetSegmentTrackReport(pub id);
impl std::ops::Deref for AVAssetSegmentTrackReport {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetSegmentTrackReport {}
impl AVAssetSegmentTrackReport {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentTrackReport").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetSegmentTrackReport {}
impl PNSObject for AVAssetSegmentTrackReport {}
impl std::convert::TryFrom<NSObject> for AVAssetSegmentTrackReport {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetSegmentTrackReport, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetSegmentTrackReport").unwrap()) };
        if is_kind_of {
            Ok(AVAssetSegmentTrackReport(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetSegmentTrackReport")
        }
    }
}
impl IAVAssetSegmentTrackReport for AVAssetSegmentTrackReport {}
pub trait IAVAssetSegmentTrackReport: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn earliestPresentationTimeStamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, earliestPresentationTimeStamp)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn firstVideoSampleInformation(&self) -> AVAssetSegmentReportSampleInformation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, firstVideoSampleInformation)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentTrackReport").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetSegmentReportSampleInformation(pub id);
impl std::ops::Deref for AVAssetSegmentReportSampleInformation {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetSegmentReportSampleInformation {}
impl AVAssetSegmentReportSampleInformation {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentReportSampleInformation").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetSegmentReportSampleInformation {}
impl PNSObject for AVAssetSegmentReportSampleInformation {}
impl std::convert::TryFrom<NSObject> for AVAssetSegmentReportSampleInformation {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetSegmentReportSampleInformation, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetSegmentReportSampleInformation").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetSegmentReportSampleInformation(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetSegmentReportSampleInformation")
        }
    }
}
impl IAVAssetSegmentReportSampleInformation for AVAssetSegmentReportSampleInformation {}
pub trait IAVAssetSegmentReportSampleInformation: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn presentationTimeStamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, presentationTimeStamp)
    }
    unsafe fn offset(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, offset)
    }
    unsafe fn length(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, length)
    }
    unsafe fn isSyncSample(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSyncSample)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetSegmentReportSampleInformation").unwrap(), new)
    }
}
pub type AVAssetWriterStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriter(pub id);
impl std::ops::Deref for AVAssetWriter {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriter {}
impl AVAssetWriter {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriter").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriter {}
impl PNSObject for AVAssetWriter {}
impl std::convert::TryFrom<NSObject> for AVAssetWriter {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriter, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriter").unwrap()) };
        if is_kind_of {
            Ok(AVAssetWriter(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriter")
        }
    }
}
impl IAVAssetWriter for AVAssetWriter {}
pub trait IAVAssetWriter: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithURL_fileType_error_(
        &self,
        outputURL: NSURL,
        outputFileType: NSString,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : outputURL, fileType : outputFileType, error : outError)
    }
    unsafe fn initWithContentType_(&self, outputContentType: UTType) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithContentType : outputContentType)
    }
    unsafe fn canApplyOutputSettings_forMediaType_(
        &self,
        outputSettings: NSDictionary,
        mediaType: NSString,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canApplyOutputSettings : outputSettings, forMediaType : mediaType)
    }
    unsafe fn canAddInput_(&self, input: AVAssetWriterInput) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddInput : input)
    }
    unsafe fn addInput_(&self, input: AVAssetWriterInput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addInput : input)
    }
    unsafe fn startWriting(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startWriting)
    }
    unsafe fn startSessionAtSourceTime_(&self, startTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startSessionAtSourceTime : startTime)
    }
    unsafe fn endSessionAtSourceTime_(&self, endTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, endSessionAtSourceTime : endTime)
    }
    unsafe fn cancelWriting(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelWriting)
    }
    unsafe fn finishWriting(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, finishWriting)
    }
    unsafe fn finishWritingWithCompletionHandler_(&self, handler: *mut ::std::os::raw::c_void)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, finishWritingWithCompletionHandler : handler)
    }
    unsafe fn outputURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputURL)
    }
    unsafe fn outputFileType(&self) -> AVFileType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputFileType)
    }
    unsafe fn availableMediaTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMediaTypes)
    }
    unsafe fn status(&self) -> AVAssetWriterStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn shouldOptimizeForNetworkUse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldOptimizeForNetworkUse)
    }
    unsafe fn setShouldOptimizeForNetworkUse_(&self, shouldOptimizeForNetworkUse: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setShouldOptimizeForNetworkUse : shouldOptimizeForNetworkUse)
    }
    unsafe fn directoryForTemporaryFiles(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, directoryForTemporaryFiles)
    }
    unsafe fn setDirectoryForTemporaryFiles_(&self, directoryForTemporaryFiles: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDirectoryForTemporaryFiles : directoryForTemporaryFiles)
    }
    unsafe fn inputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputs)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriter").unwrap(), new)
    }
    unsafe fn assetWriterWithURL_fileType_error_(
        outputURL: NSURL,
        outputFileType: NSString,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriter").unwrap(), assetWriterWithURL : outputURL, fileType : outputFileType, error : outError)
    }
}
impl AVAssetWriter_AVAssetWriterFileTypeSpecificProperties for AVAssetWriter {}
pub trait AVAssetWriter_AVAssetWriterFileTypeSpecificProperties: Sized + std::ops::Deref {
    unsafe fn movieFragmentInterval(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, movieFragmentInterval)
    }
    unsafe fn setMovieFragmentInterval_(&self, movieFragmentInterval: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMovieFragmentInterval : movieFragmentInterval)
    }
    unsafe fn initialMovieFragmentInterval(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, initialMovieFragmentInterval)
    }
    unsafe fn setInitialMovieFragmentInterval_(&self, initialMovieFragmentInterval: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInitialMovieFragmentInterval : initialMovieFragmentInterval)
    }
    unsafe fn initialMovieFragmentSequenceNumber(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, initialMovieFragmentSequenceNumber)
    }
    unsafe fn setInitialMovieFragmentSequenceNumber_(
        &self,
        initialMovieFragmentSequenceNumber: NSInteger,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInitialMovieFragmentSequenceNumber : initialMovieFragmentSequenceNumber)
    }
    unsafe fn producesCombinableFragments(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, producesCombinableFragments)
    }
    unsafe fn setProducesCombinableFragments_(&self, producesCombinableFragments: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setProducesCombinableFragments : producesCombinableFragments)
    }
    unsafe fn overallDurationHint(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, overallDurationHint)
    }
    unsafe fn setOverallDurationHint_(&self, overallDurationHint: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOverallDurationHint : overallDurationHint)
    }
    unsafe fn movieTimeScale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, movieTimeScale)
    }
    unsafe fn setMovieTimeScale_(&self, movieTimeScale: CMTimeScale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMovieTimeScale : movieTimeScale)
    }
}
impl AVAssetWriter_AVAssetWriterInputGroups for AVAssetWriter {}
pub trait AVAssetWriter_AVAssetWriterInputGroups: Sized + std::ops::Deref {
    unsafe fn canAddInputGroup_(&self, inputGroup: AVAssetWriterInputGroup) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddInputGroup : inputGroup)
    }
    unsafe fn addInputGroup_(&self, inputGroup: AVAssetWriterInputGroup)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addInputGroup : inputGroup)
    }
    unsafe fn inputGroups(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputGroups)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputGroup(pub id);
impl std::ops::Deref for AVAssetWriterInputGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputGroup {}
impl AVAssetWriterInputGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputGroup").unwrap(), alloc) })
    }
}
impl IAVMediaSelectionGroup for AVAssetWriterInputGroup {}
impl PNSCopying for AVAssetWriterInputGroup {}
impl From<AVAssetWriterInputGroup> for AVMediaSelectionGroup {
    fn from(child: AVAssetWriterInputGroup) -> AVMediaSelectionGroup {
        AVMediaSelectionGroup(child.0)
    }
}
impl std::convert::TryFrom<AVMediaSelectionGroup> for AVAssetWriterInputGroup {
    type Error = &'static str;
    fn try_from(parent: AVMediaSelectionGroup) -> Result<AVAssetWriterInputGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputGroup").unwrap()) };
        if is_kind_of {
            Ok(AVAssetWriterInputGroup(parent.0))
        } else {
            Err("This AVMediaSelectionGroup cannot be downcasted to AVAssetWriterInputGroup")
        }
    }
}
impl INSObject for AVAssetWriterInputGroup {}
impl PNSObject for AVAssetWriterInputGroup {}
impl IAVAssetWriterInputGroup for AVAssetWriterInputGroup {}
pub trait IAVAssetWriterInputGroup: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithInputs_defaultInput_(
        &self,
        inputs: NSArray,
        defaultInput: AVAssetWriterInput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithInputs : inputs, defaultInput : defaultInput)
    }
    unsafe fn inputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputs)
    }
    unsafe fn defaultInput(&self) -> AVAssetWriterInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultInput)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputGroup").unwrap(), new)
    }
    unsafe fn assetWriterInputGroupWithInputs_defaultInput_(
        inputs: NSArray,
        defaultInput: AVAssetWriterInput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputGroup").unwrap(), assetWriterInputGroupWithInputs : inputs, defaultInput : defaultInput)
    }
}
impl AVAssetWriter_AVAssetWriterSegmentation for AVAssetWriter {}
pub trait AVAssetWriter_AVAssetWriterSegmentation: Sized + std::ops::Deref {
    unsafe fn flushSegment(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flushSegment)
    }
    unsafe fn preferredOutputSegmentInterval(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredOutputSegmentInterval)
    }
    unsafe fn setPreferredOutputSegmentInterval_(&self, preferredOutputSegmentInterval: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredOutputSegmentInterval : preferredOutputSegmentInterval)
    }
    unsafe fn initialSegmentStartTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, initialSegmentStartTime)
    }
    unsafe fn setInitialSegmentStartTime_(&self, initialSegmentStartTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInitialSegmentStartTime : initialSegmentStartTime)
    }
    unsafe fn outputFileTypeProfile(&self) -> AVFileTypeProfile
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputFileTypeProfile)
    }
    unsafe fn setOutputFileTypeProfile_(&self, outputFileTypeProfile: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputFileTypeProfile : outputFileTypeProfile)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn setDelegate_(&self, delegate: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate)
    }
}
pub trait PAVAssetWriterDelegate: Sized + std::ops::Deref {
    unsafe fn assetWriter_didOutputSegmentData_segmentType_segmentReport_(
        &self,
        writer: AVAssetWriter,
        segmentData: NSData,
        segmentType: AVAssetSegmentType,
        segmentReport: AVAssetSegmentReport,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, assetWriter : writer, didOutputSegmentData : segmentData, segmentType : segmentType, segmentReport : segmentReport)
    }
    unsafe fn assetWriter_didOutputSegmentData_segmentType_(
        &self,
        writer: AVAssetWriter,
        segmentData: NSData,
        segmentType: AVAssetSegmentType,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, assetWriter : writer, didOutputSegmentData : segmentData, segmentType : segmentType)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInput(pub id);
impl std::ops::Deref for AVAssetWriterInput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInput {}
impl AVAssetWriterInput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInput").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriterInput {}
impl PNSObject for AVAssetWriterInput {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriterInput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInput").unwrap()) };
        if is_kind_of {
            Ok(AVAssetWriterInput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriterInput")
        }
    }
}
impl IAVAssetWriterInput for AVAssetWriterInput {}
pub trait IAVAssetWriterInput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithMediaType_outputSettings_(
        &self,
        mediaType: NSString,
        outputSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithMediaType : mediaType, outputSettings : outputSettings)
    }
    unsafe fn initWithMediaType_outputSettings_sourceFormatHint_(
        &self,
        mediaType: NSString,
        outputSettings: NSDictionary,
        sourceFormatHint: CMFormatDescriptionRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithMediaType : mediaType, outputSettings : outputSettings, sourceFormatHint : sourceFormatHint)
    }
    unsafe fn requestMediaDataWhenReadyOnQueue_usingBlock_(
        &self,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, requestMediaDataWhenReadyOnQueue : queue, usingBlock : block)
    }
    unsafe fn appendSampleBuffer_(&self, sampleBuffer: CMSampleBufferRef) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendSampleBuffer : sampleBuffer)
    }
    unsafe fn markAsFinished(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, markAsFinished)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn outputSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputSettings)
    }
    unsafe fn sourceFormatHint(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceFormatHint)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn isReadyForMoreMediaData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyForMoreMediaData)
    }
    unsafe fn expectsMediaDataInRealTime(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expectsMediaDataInRealTime)
    }
    unsafe fn setExpectsMediaDataInRealTime_(&self, expectsMediaDataInRealTime: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExpectsMediaDataInRealTime : expectsMediaDataInRealTime)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInput").unwrap(), new)
    }
    unsafe fn assetWriterInputWithMediaType_outputSettings_(
        mediaType: NSString,
        outputSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInput").unwrap(), assetWriterInputWithMediaType : mediaType, outputSettings : outputSettings)
    }
    unsafe fn assetWriterInputWithMediaType_outputSettings_sourceFormatHint_(
        mediaType: NSString,
        outputSettings: NSDictionary,
        sourceFormatHint: CMFormatDescriptionRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInput").unwrap(), assetWriterInputWithMediaType : mediaType, outputSettings : outputSettings, sourceFormatHint : sourceFormatHint)
    }
}
impl AVAssetWriterInput_AVAssetWriterInputLanguageProperties for AVAssetWriterInput {}
pub trait AVAssetWriterInput_AVAssetWriterInputLanguageProperties: Sized + std::ops::Deref {
    unsafe fn languageCode(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, languageCode)
    }
    unsafe fn setLanguageCode_(&self, languageCode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLanguageCode : languageCode)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn setExtendedLanguageTag_(&self, extendedLanguageTag: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExtendedLanguageTag : extendedLanguageTag)
    }
}
impl AVAssetWriterInput_AVAssetWriterInputPropertiesForVisualCharacteristic for AVAssetWriterInput {}
pub trait AVAssetWriterInput_AVAssetWriterInputPropertiesForVisualCharacteristic:
    Sized + std::ops::Deref
{
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn setNaturalSize_(&self, naturalSize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setNaturalSize : naturalSize)
    }
    unsafe fn transform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transform)
    }
    unsafe fn setTransform_(&self, transform: CGAffineTransform)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTransform : transform)
    }
}
impl AVAssetWriterInput_AVAssetWriterInputPropertiesForAudibleCharacteristic
    for AVAssetWriterInput
{
}
pub trait AVAssetWriterInput_AVAssetWriterInputPropertiesForAudibleCharacteristic:
    Sized + std::ops::Deref
{
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn setPreferredVolume_(&self, preferredVolume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVolume : preferredVolume)
    }
}
impl AVAssetWriterInput_AVAssetWriterInputFileTypeSpecificProperties for AVAssetWriterInput {}
pub trait AVAssetWriterInput_AVAssetWriterInputFileTypeSpecificProperties:
    Sized + std::ops::Deref
{
    unsafe fn marksOutputTrackAsEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, marksOutputTrackAsEnabled)
    }
    unsafe fn setMarksOutputTrackAsEnabled_(&self, marksOutputTrackAsEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMarksOutputTrackAsEnabled : marksOutputTrackAsEnabled)
    }
    unsafe fn mediaTimeScale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaTimeScale)
    }
    unsafe fn setMediaTimeScale_(&self, mediaTimeScale: CMTimeScale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMediaTimeScale : mediaTimeScale)
    }
    unsafe fn preferredMediaChunkDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaChunkDuration)
    }
    unsafe fn setPreferredMediaChunkDuration_(&self, preferredMediaChunkDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMediaChunkDuration : preferredMediaChunkDuration)
    }
    unsafe fn preferredMediaChunkAlignment(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaChunkAlignment)
    }
    unsafe fn setPreferredMediaChunkAlignment_(&self, preferredMediaChunkAlignment: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMediaChunkAlignment : preferredMediaChunkAlignment)
    }
    unsafe fn sampleReferenceBaseURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleReferenceBaseURL)
    }
    unsafe fn setSampleReferenceBaseURL_(&self, sampleReferenceBaseURL: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSampleReferenceBaseURL : sampleReferenceBaseURL)
    }
    unsafe fn mediaDataLocation(&self) -> AVAssetWriterInputMediaDataLocation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaDataLocation)
    }
    unsafe fn setMediaDataLocation_(&self, mediaDataLocation: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMediaDataLocation : mediaDataLocation)
    }
}
pub type AVAssetWriterInputMediaDataLocation = NSString;
impl AVAssetWriterInput_AVAssetWriterInputTrackAssociations for AVAssetWriterInput {}
pub trait AVAssetWriterInput_AVAssetWriterInputTrackAssociations: Sized + std::ops::Deref {
    unsafe fn canAddTrackAssociationWithTrackOfInput_type_(
        &self,
        input: AVAssetWriterInput,
        trackAssociationType: NSString,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddTrackAssociationWithTrackOfInput : input, r#type : trackAssociationType)
    }
    unsafe fn addTrackAssociationWithTrackOfInput_type_(
        &self,
        input: AVAssetWriterInput,
        trackAssociationType: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addTrackAssociationWithTrackOfInput : input, r#type : trackAssociationType)
    }
}
impl AVAssetWriterInput_AVAssetWriterInputMultiPass for AVAssetWriterInput {}
pub trait AVAssetWriterInput_AVAssetWriterInputMultiPass: Sized + std::ops::Deref {
    unsafe fn respondToEachPassDescriptionOnQueue_usingBlock_(
        &self,
        queue: NSObject,
        block: dispatch_block_t,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, respondToEachPassDescriptionOnQueue : queue, usingBlock : block)
    }
    unsafe fn markCurrentPassAsFinished(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, markCurrentPassAsFinished)
    }
    unsafe fn performsMultiPassEncodingIfSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, performsMultiPassEncodingIfSupported)
    }
    unsafe fn setPerformsMultiPassEncodingIfSupported_(
        &self,
        performsMultiPassEncodingIfSupported: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPerformsMultiPassEncodingIfSupported : performsMultiPassEncodingIfSupported)
    }
    unsafe fn canPerformMultiplePasses(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPerformMultiplePasses)
    }
    unsafe fn currentPassDescription(&self) -> AVAssetWriterInputPassDescription
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentPassDescription)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputPassDescription(pub id);
impl std::ops::Deref for AVAssetWriterInputPassDescription {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputPassDescription {}
impl AVAssetWriterInputPassDescription {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputPassDescription").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriterInputPassDescription {}
impl PNSObject for AVAssetWriterInputPassDescription {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInputPassDescription {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriterInputPassDescription, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputPassDescription").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetWriterInputPassDescription(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriterInputPassDescription")
        }
    }
}
impl IAVAssetWriterInputPassDescription for AVAssetWriterInputPassDescription {}
pub trait IAVAssetWriterInputPassDescription: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn sourceTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceTimeRanges)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputPassDescription").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputPixelBufferAdaptor(pub id);
impl std::ops::Deref for AVAssetWriterInputPixelBufferAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputPixelBufferAdaptor {}
impl AVAssetWriterInputPixelBufferAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputPixelBufferAdaptor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriterInputPixelBufferAdaptor {}
impl PNSObject for AVAssetWriterInputPixelBufferAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInputPixelBufferAdaptor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriterInputPixelBufferAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputPixelBufferAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetWriterInputPixelBufferAdaptor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriterInputPixelBufferAdaptor")
        }
    }
}
impl IAVAssetWriterInputPixelBufferAdaptor for AVAssetWriterInputPixelBufferAdaptor {}
pub trait IAVAssetWriterInputPixelBufferAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetWriterInput_sourcePixelBufferAttributes_(
        &self,
        input: AVAssetWriterInput,
        sourcePixelBufferAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetWriterInput : input, sourcePixelBufferAttributes : sourcePixelBufferAttributes)
    }
    unsafe fn appendPixelBuffer_withPresentationTime_(
        &self,
        pixelBuffer: CVPixelBufferRef,
        presentationTime: CMTime,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendPixelBuffer : pixelBuffer, withPresentationTime : presentationTime)
    }
    unsafe fn assetWriterInput(&self) -> AVAssetWriterInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetWriterInput)
    }
    unsafe fn sourcePixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourcePixelBufferAttributes)
    }
    unsafe fn pixelBufferPool(&self) -> CVPixelBufferPoolRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelBufferPool)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputPixelBufferAdaptor").unwrap(), new)
    }
    unsafe fn assetWriterInputPixelBufferAdaptorWithAssetWriterInput_sourcePixelBufferAttributes_(
        input: AVAssetWriterInput,
        sourcePixelBufferAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputPixelBufferAdaptor").unwrap(), assetWriterInputPixelBufferAdaptorWithAssetWriterInput : input, sourcePixelBufferAttributes : sourcePixelBufferAttributes)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputTaggedPixelBufferGroupAdaptor(pub id);
impl std::ops::Deref for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {}
impl AVAssetWriterInputTaggedPixelBufferGroupAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputTaggedPixelBufferGroupAdaptor").unwrap(), alloc)
        })
    }
}
impl INSObject for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {}
impl PNSObject for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVAssetWriterInputTaggedPixelBufferGroupAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputTaggedPixelBufferGroupAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetWriterInputTaggedPixelBufferGroupAdaptor(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVAssetWriterInputTaggedPixelBufferGroupAdaptor" ,)
        }
    }
}
impl IAVAssetWriterInputTaggedPixelBufferGroupAdaptor
    for AVAssetWriterInputTaggedPixelBufferGroupAdaptor
{
}
pub trait IAVAssetWriterInputTaggedPixelBufferGroupAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetWriterInput_sourcePixelBufferAttributes_(
        &self,
        input: AVAssetWriterInput,
        sourcePixelBufferAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetWriterInput : input, sourcePixelBufferAttributes : sourcePixelBufferAttributes)
    }
    unsafe fn appendTaggedPixelBufferGroup_withPresentationTime_(
        &self,
        taggedPixelBufferGroup: CMTaggedBufferGroupRef,
        presentationTime: CMTime,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendTaggedPixelBufferGroup : taggedPixelBufferGroup, withPresentationTime : presentationTime)
    }
    unsafe fn assetWriterInput(&self) -> AVAssetWriterInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetWriterInput)
    }
    unsafe fn sourcePixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourcePixelBufferAttributes)
    }
    unsafe fn pixelBufferPool(&self) -> CVPixelBufferPoolRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelBufferPool)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputTaggedPixelBufferGroupAdaptor").unwrap(), new)
    }
    unsafe fn assetWriterInputTaggedPixelBufferGroupAdaptorWithAssetWriterInput_sourcePixelBufferAttributes_(
        input: AVAssetWriterInput,
        sourcePixelBufferAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputTaggedPixelBufferGroupAdaptor").unwrap(), assetWriterInputTaggedPixelBufferGroupAdaptorWithAssetWriterInput : input, sourcePixelBufferAttributes : sourcePixelBufferAttributes)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputMetadataAdaptor(pub id);
impl std::ops::Deref for AVAssetWriterInputMetadataAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputMetadataAdaptor {}
impl AVAssetWriterInputMetadataAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputMetadataAdaptor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriterInputMetadataAdaptor {}
impl PNSObject for AVAssetWriterInputMetadataAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInputMetadataAdaptor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriterInputMetadataAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputMetadataAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetWriterInputMetadataAdaptor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriterInputMetadataAdaptor")
        }
    }
}
impl IAVAssetWriterInputMetadataAdaptor for AVAssetWriterInputMetadataAdaptor {}
pub trait IAVAssetWriterInputMetadataAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetWriterInput_(&self, input: AVAssetWriterInput) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetWriterInput : input)
    }
    unsafe fn appendTimedMetadataGroup_(&self, timedMetadataGroup: AVTimedMetadataGroup) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendTimedMetadataGroup : timedMetadataGroup)
    }
    unsafe fn assetWriterInput(&self) -> AVAssetWriterInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetWriterInput)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputMetadataAdaptor").unwrap(), new)
    }
    unsafe fn assetWriterInputMetadataAdaptorWithAssetWriterInput_(
        input: AVAssetWriterInput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputMetadataAdaptor").unwrap(), assetWriterInputMetadataAdaptorWithAssetWriterInput : input)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetWriterInputCaptionAdaptor(pub id);
impl std::ops::Deref for AVAssetWriterInputCaptionAdaptor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetWriterInputCaptionAdaptor {}
impl AVAssetWriterInputCaptionAdaptor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputCaptionAdaptor").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetWriterInputCaptionAdaptor {}
impl PNSObject for AVAssetWriterInputCaptionAdaptor {}
impl std::convert::TryFrom<NSObject> for AVAssetWriterInputCaptionAdaptor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetWriterInputCaptionAdaptor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetWriterInputCaptionAdaptor").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetWriterInputCaptionAdaptor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetWriterInputCaptionAdaptor")
        }
    }
}
impl IAVAssetWriterInputCaptionAdaptor for AVAssetWriterInputCaptionAdaptor {}
pub trait IAVAssetWriterInputCaptionAdaptor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAssetWriterInput_(&self, input: AVAssetWriterInput) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAssetWriterInput : input)
    }
    unsafe fn appendCaption_(&self, caption: AVCaption) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendCaption : caption)
    }
    unsafe fn appendCaptionGroup_(&self, captionGroup: AVCaptionGroup) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendCaptionGroup : captionGroup)
    }
    unsafe fn assetWriterInput(&self) -> AVAssetWriterInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetWriterInput)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputCaptionAdaptor").unwrap(), new)
    }
    unsafe fn assetWriterInputCaptionAdaptorWithAssetWriterInput_(
        input: AVAssetWriterInput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetWriterInputCaptionAdaptor").unwrap(), assetWriterInputCaptionAdaptorWithAssetWriterInput : input)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetPlaybackAssistant(pub id);
impl std::ops::Deref for AVAssetPlaybackAssistant {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetPlaybackAssistant {}
impl AVAssetPlaybackAssistant {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetPlaybackAssistant").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetPlaybackAssistant {}
impl PNSObject for AVAssetPlaybackAssistant {}
impl std::convert::TryFrom<NSObject> for AVAssetPlaybackAssistant {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetPlaybackAssistant, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetPlaybackAssistant").unwrap()) };
        if is_kind_of {
            Ok(AVAssetPlaybackAssistant(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetPlaybackAssistant")
        }
    }
}
impl IAVAssetPlaybackAssistant for AVAssetPlaybackAssistant {}
pub trait IAVAssetPlaybackAssistant: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn loadPlaybackConfigurationOptionsWithCompletionHandler_(
        &self,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadPlaybackConfigurationOptionsWithCompletionHandler : completionHandler)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetPlaybackAssistant").unwrap(), new)
    }
    unsafe fn assetPlaybackAssistantWithAsset_(asset: AVAsset) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetPlaybackAssistant").unwrap(), assetPlaybackAssistantWithAsset : asset)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAudioMix(pub id);
impl std::ops::Deref for AVAudioMix {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAudioMix {}
impl AVAudioMix {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAudioMix").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAudioMix {}
impl PNSMutableCopying for AVAudioMix {}
impl INSObject for AVAudioMix {}
impl PNSObject for AVAudioMix {}
impl std::convert::TryFrom<NSObject> for AVAudioMix {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAudioMix, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAudioMix").unwrap()) };
        if is_kind_of {
            Ok(AVAudioMix(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAudioMix")
        }
    }
}
impl IAVAudioMix for AVAudioMix {}
pub trait IAVAudioMix: Sized + std::ops::Deref {
    unsafe fn inputParameters(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputParameters)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableAudioMix(pub id);
impl std::ops::Deref for AVMutableAudioMix {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableAudioMix {}
impl AVMutableAudioMix {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAudioMix").unwrap(), alloc) })
    }
}
impl IAVAudioMix for AVMutableAudioMix {}
impl PNSCopying for AVMutableAudioMix {}
impl PNSMutableCopying for AVMutableAudioMix {}
impl From<AVMutableAudioMix> for AVAudioMix {
    fn from(child: AVMutableAudioMix) -> AVAudioMix {
        AVAudioMix(child.0)
    }
}
impl std::convert::TryFrom<AVAudioMix> for AVMutableAudioMix {
    type Error = &'static str;
    fn try_from(parent: AVAudioMix) -> Result<AVMutableAudioMix, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableAudioMix").unwrap()) };
        if is_kind_of {
            Ok(AVMutableAudioMix(parent.0))
        } else {
            Err("This AVAudioMix cannot be downcasted to AVMutableAudioMix")
        }
    }
}
impl INSObject for AVMutableAudioMix {}
impl PNSObject for AVMutableAudioMix {}
impl IAVMutableAudioMix for AVMutableAudioMix {}
pub trait IAVMutableAudioMix: Sized + std::ops::Deref {
    unsafe fn inputParameters(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputParameters)
    }
    unsafe fn setInputParameters_(&self, inputParameters: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInputParameters : inputParameters)
    }
    unsafe fn audioMix() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAudioMix").unwrap(), audioMix)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAudioMixInputParameters(pub id);
impl std::ops::Deref for AVAudioMixInputParameters {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAudioMixInputParameters {}
impl AVAudioMixInputParameters {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAudioMixInputParameters").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAudioMixInputParameters {}
impl PNSMutableCopying for AVAudioMixInputParameters {}
impl INSObject for AVAudioMixInputParameters {}
impl PNSObject for AVAudioMixInputParameters {}
impl std::convert::TryFrom<NSObject> for AVAudioMixInputParameters {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAudioMixInputParameters, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAudioMixInputParameters").unwrap()) };
        if is_kind_of {
            Ok(AVAudioMixInputParameters(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAudioMixInputParameters")
        }
    }
}
impl IAVAudioMixInputParameters for AVAudioMixInputParameters {}
pub trait IAVAudioMixInputParameters: Sized + std::ops::Deref {
    unsafe fn getVolumeRampForTime_startVolume_endVolume_timeRange_(
        &self,
        time: CMTime,
        startVolume: *mut f32,
        endVolume: *mut f32,
        timeRange: *mut CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, getVolumeRampForTime : time, startVolume : startVolume, endVolume : endVolume, timeRange : timeRange)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn audioTapProcessor(&self) -> MTAudioProcessingTapRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTapProcessor)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableAudioMixInputParameters(pub id);
impl std::ops::Deref for AVMutableAudioMixInputParameters {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableAudioMixInputParameters {}
impl AVMutableAudioMixInputParameters {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAudioMixInputParameters").unwrap(), alloc) })
    }
}
impl IAVAudioMixInputParameters for AVMutableAudioMixInputParameters {}
impl PNSCopying for AVMutableAudioMixInputParameters {}
impl PNSMutableCopying for AVMutableAudioMixInputParameters {}
impl From<AVMutableAudioMixInputParameters> for AVAudioMixInputParameters {
    fn from(child: AVMutableAudioMixInputParameters) -> AVAudioMixInputParameters {
        AVAudioMixInputParameters(child.0)
    }
}
impl std::convert::TryFrom<AVAudioMixInputParameters> for AVMutableAudioMixInputParameters {
    type Error = &'static str;
    fn try_from(
        parent: AVAudioMixInputParameters,
    ) -> Result<AVMutableAudioMixInputParameters, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableAudioMixInputParameters").unwrap())
        };
        if is_kind_of {
            Ok(AVMutableAudioMixInputParameters(parent.0))
        } else {
            Err ("This AVAudioMixInputParameters cannot be downcasted to AVMutableAudioMixInputParameters" ,)
        }
    }
}
impl INSObject for AVMutableAudioMixInputParameters {}
impl PNSObject for AVMutableAudioMixInputParameters {}
impl IAVMutableAudioMixInputParameters for AVMutableAudioMixInputParameters {}
pub trait IAVMutableAudioMixInputParameters: Sized + std::ops::Deref {
    unsafe fn setVolumeRampFromStartVolume_toEndVolume_timeRange_(
        &self,
        startVolume: f32,
        endVolume: f32,
        timeRange: CMTimeRange,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolumeRampFromStartVolume : startVolume, toEndVolume : endVolume, timeRange : timeRange)
    }
    unsafe fn setVolume_atTime_(&self, volume: f32, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolume : volume, atTime : time)
    }
    unsafe fn trackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, trackID)
    }
    unsafe fn setTrackID_(&self, trackID: CMPersistentTrackID)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTrackID : trackID)
    }
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn audioTapProcessor(&self) -> MTAudioProcessingTapRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTapProcessor)
    }
    unsafe fn setAudioTapProcessor_(&self, audioTapProcessor: MTAudioProcessingTapRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTapProcessor : audioTapProcessor)
    }
    unsafe fn audioMixInputParametersWithTrack_(track: AVAssetTrack) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAudioMixInputParameters").unwrap(), audioMixInputParametersWithTrack : track)
    }
    unsafe fn audioMixInputParameters() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAudioMixInputParameters").unwrap(), audioMixInputParameters)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaSelection(pub id);
impl std::ops::Deref for AVMediaSelection {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaSelection {}
impl AVMediaSelection {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaSelection").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMediaSelection {}
impl PNSMutableCopying for AVMediaSelection {}
impl INSObject for AVMediaSelection {}
impl PNSObject for AVMediaSelection {}
impl std::convert::TryFrom<NSObject> for AVMediaSelection {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaSelection, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaSelection").unwrap()) };
        if is_kind_of {
            Ok(AVMediaSelection(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaSelection")
        }
    }
}
impl IAVMediaSelection for AVMediaSelection {}
pub trait IAVMediaSelection: Sized + std::ops::Deref {
    unsafe fn selectedMediaOptionInMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> AVMediaSelectionOption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectedMediaOptionInMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn mediaSelectionCriteriaCanBeAppliedAutomaticallyToMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionCriteriaCanBeAppliedAutomaticallyToMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableMediaSelection(pub id);
impl std::ops::Deref for AVMutableMediaSelection {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableMediaSelection {}
impl AVMutableMediaSelection {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMediaSelection").unwrap(), alloc) })
    }
}
impl IAVMediaSelection for AVMutableMediaSelection {}
impl PNSCopying for AVMutableMediaSelection {}
impl PNSMutableCopying for AVMutableMediaSelection {}
impl From<AVMutableMediaSelection> for AVMediaSelection {
    fn from(child: AVMutableMediaSelection) -> AVMediaSelection {
        AVMediaSelection(child.0)
    }
}
impl std::convert::TryFrom<AVMediaSelection> for AVMutableMediaSelection {
    type Error = &'static str;
    fn try_from(parent: AVMediaSelection) -> Result<AVMutableMediaSelection, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableMediaSelection").unwrap()) };
        if is_kind_of {
            Ok(AVMutableMediaSelection(parent.0))
        } else {
            Err("This AVMediaSelection cannot be downcasted to AVMutableMediaSelection")
        }
    }
}
impl INSObject for AVMutableMediaSelection {}
impl PNSObject for AVMutableMediaSelection {}
impl IAVMutableMediaSelection for AVMutableMediaSelection {}
pub trait IAVMutableMediaSelection: Sized + std::ops::Deref {
    unsafe fn selectMediaOption_inMediaSelectionGroup_(
        &self,
        mediaSelectionOption: AVMediaSelectionOption,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectMediaOption : mediaSelectionOption, inMediaSelectionGroup : mediaSelectionGroup)
    }
}
pub trait PAVMetricEventStreamPublisher: Sized + std::ops::Deref {}
pub trait PAVMetricEventStreamSubscriber: Sized + std::ops::Deref {
    unsafe fn publisher_didReceiveEvent_(&self, publisher: *mut u64, event: AVMetricEvent)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, publisher : publisher, didReceiveEvent : event)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricEventStream(pub id);
impl std::ops::Deref for AVMetricEventStream {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricEventStream {}
impl AVMetricEventStream {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricEventStream").unwrap(), alloc) })
    }
}
impl INSObject for AVMetricEventStream {}
impl PNSObject for AVMetricEventStream {}
impl std::convert::TryFrom<NSObject> for AVMetricEventStream {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetricEventStream, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricEventStream").unwrap()) };
        if is_kind_of {
            Ok(AVMetricEventStream(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetricEventStream")
        }
    }
}
impl IAVMetricEventStream for AVMetricEventStream {}
pub trait IAVMetricEventStream: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn addPublisher_(&self, publisher: *mut u64) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addPublisher : publisher)
    }
    unsafe fn setSubscriber_queue_(&self, subscriber: *mut u64, queue: NSObject) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSubscriber : subscriber, queue : queue)
    }
    unsafe fn subscribeToMetricEvent_(&self, metricEventClass: Class)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, subscribeToMetricEvent : metricEventClass)
    }
    unsafe fn subscribeToMetricEvents_(&self, metricEventClasses: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, subscribeToMetricEvents : metricEventClasses)
    }
    unsafe fn subscribeToAllMetricEvents(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, subscribeToAllMetricEvents)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricEventStream").unwrap(), new)
    }
    unsafe fn eventStream() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricEventStream").unwrap(), eventStream)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricEvent(pub id);
impl std::ops::Deref for AVMetricEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricEvent {}
impl AVMetricEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricEvent").unwrap(), alloc) })
    }
}
impl PNSSecureCoding for AVMetricEvent {}
impl INSObject for AVMetricEvent {}
impl PNSObject for AVMetricEvent {}
impl std::convert::TryFrom<NSObject> for AVMetricEvent {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetricEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricEvent").unwrap()) };
        if is_kind_of {
            Ok(AVMetricEvent(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetricEvent")
        }
    }
}
impl IAVMetricEvent for AVMetricEvent {}
pub trait IAVMetricEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn date(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, date)
    }
    unsafe fn mediaTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaTime)
    }
    unsafe fn sessionID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sessionID)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricErrorEvent(pub id);
impl std::ops::Deref for AVMetricErrorEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricErrorEvent {}
impl AVMetricErrorEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricErrorEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricErrorEvent {}
impl PNSSecureCoding for AVMetricErrorEvent {}
impl From<AVMetricErrorEvent> for AVMetricEvent {
    fn from(child: AVMetricErrorEvent) -> AVMetricEvent {
        AVMetricEvent(child.0)
    }
}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricErrorEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricErrorEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricErrorEvent").unwrap()) };
        if is_kind_of {
            Ok(AVMetricErrorEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricErrorEvent")
        }
    }
}
impl INSObject for AVMetricErrorEvent {}
impl PNSObject for AVMetricErrorEvent {}
impl IAVMetricErrorEvent for AVMetricErrorEvent {}
pub trait IAVMetricErrorEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn didRecover(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, didRecover)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricErrorEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricMediaResourceRequestEvent(pub id);
impl std::ops::Deref for AVMetricMediaResourceRequestEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricMediaResourceRequestEvent {}
impl AVMetricMediaResourceRequestEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricMediaResourceRequestEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricMediaResourceRequestEvent {}
impl PNSSecureCoding for AVMetricMediaResourceRequestEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricMediaResourceRequestEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricMediaResourceRequestEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricMediaResourceRequestEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricMediaResourceRequestEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricMediaResourceRequestEvent")
        }
    }
}
impl INSObject for AVMetricMediaResourceRequestEvent {}
impl PNSObject for AVMetricMediaResourceRequestEvent {}
impl IAVMetricMediaResourceRequestEvent for AVMetricMediaResourceRequestEvent {}
pub trait IAVMetricMediaResourceRequestEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn url(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, url)
    }
    unsafe fn serverAddress(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, serverAddress)
    }
    unsafe fn requestStartTime(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestStartTime)
    }
    unsafe fn requestEndTime(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requestEndTime)
    }
    unsafe fn responseStartTime(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, responseStartTime)
    }
    unsafe fn responseEndTime(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, responseEndTime)
    }
    unsafe fn byteRange(&self) -> NSRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, byteRange)
    }
    unsafe fn wasReadFromCache(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, wasReadFromCache)
    }
    unsafe fn errorEvent(&self) -> AVMetricErrorEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorEvent)
    }
    unsafe fn networkTransactionMetrics(&self) -> NSURLSessionTaskMetrics
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, networkTransactionMetrics)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricMediaResourceRequestEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricHLSPlaylistRequestEvent(pub id);
impl std::ops::Deref for AVMetricHLSPlaylistRequestEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricHLSPlaylistRequestEvent {}
impl AVMetricHLSPlaylistRequestEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricHLSPlaylistRequestEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricHLSPlaylistRequestEvent {}
impl PNSSecureCoding for AVMetricHLSPlaylistRequestEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricHLSPlaylistRequestEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricHLSPlaylistRequestEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricHLSPlaylistRequestEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricHLSPlaylistRequestEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricHLSPlaylistRequestEvent")
        }
    }
}
impl INSObject for AVMetricHLSPlaylistRequestEvent {}
impl PNSObject for AVMetricHLSPlaylistRequestEvent {}
impl IAVMetricHLSPlaylistRequestEvent for AVMetricHLSPlaylistRequestEvent {}
pub trait IAVMetricHLSPlaylistRequestEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn url(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, url)
    }
    unsafe fn isMultivariantPlaylist(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMultivariantPlaylist)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn mediaResourceRequestEvent(&self) -> AVMetricMediaResourceRequestEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaResourceRequestEvent)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricHLSPlaylistRequestEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricHLSMediaSegmentRequestEvent(pub id);
impl std::ops::Deref for AVMetricHLSMediaSegmentRequestEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricHLSMediaSegmentRequestEvent {}
impl AVMetricHLSMediaSegmentRequestEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricHLSMediaSegmentRequestEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricHLSMediaSegmentRequestEvent {}
impl PNSSecureCoding for AVMetricHLSMediaSegmentRequestEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricHLSMediaSegmentRequestEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricHLSMediaSegmentRequestEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricHLSMediaSegmentRequestEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricHLSMediaSegmentRequestEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricHLSMediaSegmentRequestEvent")
        }
    }
}
impl INSObject for AVMetricHLSMediaSegmentRequestEvent {}
impl PNSObject for AVMetricHLSMediaSegmentRequestEvent {}
impl IAVMetricHLSMediaSegmentRequestEvent for AVMetricHLSMediaSegmentRequestEvent {}
pub trait IAVMetricHLSMediaSegmentRequestEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn url(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, url)
    }
    unsafe fn isMapSegment(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMapSegment)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn byteRange(&self) -> NSRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, byteRange)
    }
    unsafe fn indexFileURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, indexFileURL)
    }
    unsafe fn segmentDuration(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segmentDuration)
    }
    unsafe fn mediaResourceRequestEvent(&self) -> AVMetricMediaResourceRequestEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaResourceRequestEvent)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricHLSMediaSegmentRequestEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricContentKeyRequestEvent(pub id);
impl std::ops::Deref for AVMetricContentKeyRequestEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricContentKeyRequestEvent {}
impl AVMetricContentKeyRequestEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricContentKeyRequestEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricContentKeyRequestEvent {}
impl PNSSecureCoding for AVMetricContentKeyRequestEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricContentKeyRequestEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricContentKeyRequestEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricContentKeyRequestEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricContentKeyRequestEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricContentKeyRequestEvent")
        }
    }
}
impl INSObject for AVMetricContentKeyRequestEvent {}
impl PNSObject for AVMetricContentKeyRequestEvent {}
impl IAVMetricContentKeyRequestEvent for AVMetricContentKeyRequestEvent {}
pub trait IAVMetricContentKeyRequestEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn contentKeySpecifier(&self) -> AVContentKeySpecifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKeySpecifier)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn isClientInitiated(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isClientInitiated)
    }
    unsafe fn mediaResourceRequestEvent(&self) -> AVMetricMediaResourceRequestEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaResourceRequestEvent)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricContentKeyRequestEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemLikelyToKeepUpEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemLikelyToKeepUpEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemLikelyToKeepUpEvent {}
impl AVMetricPlayerItemLikelyToKeepUpEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemLikelyToKeepUpEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricPlayerItemLikelyToKeepUpEvent {}
impl PNSSecureCoding for AVMetricPlayerItemLikelyToKeepUpEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricPlayerItemLikelyToKeepUpEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricEvent,
    ) -> Result<AVMetricPlayerItemLikelyToKeepUpEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemLikelyToKeepUpEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemLikelyToKeepUpEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricPlayerItemLikelyToKeepUpEvent")
        }
    }
}
impl INSObject for AVMetricPlayerItemLikelyToKeepUpEvent {}
impl PNSObject for AVMetricPlayerItemLikelyToKeepUpEvent {}
impl IAVMetricPlayerItemLikelyToKeepUpEvent for AVMetricPlayerItemLikelyToKeepUpEvent {}
pub trait IAVMetricPlayerItemLikelyToKeepUpEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn variant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variant)
    }
    unsafe fn timeTaken(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeTaken)
    }
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemLikelyToKeepUpEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemInitialLikelyToKeepUpEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemInitialLikelyToKeepUpEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl AVMetricPlayerItemInitialLikelyToKeepUpEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemInitialLikelyToKeepUpEvent").unwrap(), alloc) })
    }
}
impl IAVMetricPlayerItemLikelyToKeepUpEvent for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl From<AVMetricPlayerItemInitialLikelyToKeepUpEvent> for AVMetricPlayerItemLikelyToKeepUpEvent {
    fn from(
        child: AVMetricPlayerItemInitialLikelyToKeepUpEvent,
    ) -> AVMetricPlayerItemLikelyToKeepUpEvent {
        AVMetricPlayerItemLikelyToKeepUpEvent(child.0)
    }
}
impl std::convert::TryFrom<AVMetricPlayerItemLikelyToKeepUpEvent>
    for AVMetricPlayerItemInitialLikelyToKeepUpEvent
{
    type Error = &'static str;
    fn try_from(
        parent: AVMetricPlayerItemLikelyToKeepUpEvent,
    ) -> Result<AVMetricPlayerItemInitialLikelyToKeepUpEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemInitialLikelyToKeepUpEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemInitialLikelyToKeepUpEvent(parent.0))
        } else {
            Err ("This AVMetricPlayerItemLikelyToKeepUpEvent cannot be downcasted to AVMetricPlayerItemInitialLikelyToKeepUpEvent" ,)
        }
    }
}
impl IAVMetricEvent for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl PNSSecureCoding for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl INSObject for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl PNSObject for AVMetricPlayerItemInitialLikelyToKeepUpEvent {}
impl IAVMetricPlayerItemInitialLikelyToKeepUpEvent
    for AVMetricPlayerItemInitialLikelyToKeepUpEvent
{
}
pub trait IAVMetricPlayerItemInitialLikelyToKeepUpEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn playlistRequestEvents(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playlistRequestEvents)
    }
    unsafe fn mediaSegmentRequestEvents(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaSegmentRequestEvents)
    }
    unsafe fn contentKeyRequestEvents(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentKeyRequestEvents)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemInitialLikelyToKeepUpEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemRateChangeEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemRateChangeEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemRateChangeEvent {}
impl AVMetricPlayerItemRateChangeEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemRateChangeEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricPlayerItemRateChangeEvent {}
impl PNSSecureCoding for AVMetricPlayerItemRateChangeEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricPlayerItemRateChangeEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricPlayerItemRateChangeEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemRateChangeEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemRateChangeEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricPlayerItemRateChangeEvent")
        }
    }
}
impl INSObject for AVMetricPlayerItemRateChangeEvent {}
impl PNSObject for AVMetricPlayerItemRateChangeEvent {}
impl IAVMetricPlayerItemRateChangeEvent for AVMetricPlayerItemRateChangeEvent {}
pub trait IAVMetricPlayerItemRateChangeEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn rate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rate)
    }
    unsafe fn previousRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previousRate)
    }
    unsafe fn variant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variant)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemRateChangeEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemStallEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemStallEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemStallEvent {}
impl AVMetricPlayerItemStallEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemStallEvent").unwrap(), alloc) })
    }
}
impl IAVMetricPlayerItemRateChangeEvent for AVMetricPlayerItemStallEvent {}
impl From<AVMetricPlayerItemStallEvent> for AVMetricPlayerItemRateChangeEvent {
    fn from(child: AVMetricPlayerItemStallEvent) -> AVMetricPlayerItemRateChangeEvent {
        AVMetricPlayerItemRateChangeEvent(child.0)
    }
}
impl std::convert::TryFrom<AVMetricPlayerItemRateChangeEvent> for AVMetricPlayerItemStallEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricPlayerItemRateChangeEvent,
    ) -> Result<AVMetricPlayerItemStallEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemStallEvent").unwrap()) };
        if is_kind_of {
            Ok(AVMetricPlayerItemStallEvent(parent.0))
        } else {
            Err ("This AVMetricPlayerItemRateChangeEvent cannot be downcasted to AVMetricPlayerItemStallEvent" ,)
        }
    }
}
impl IAVMetricEvent for AVMetricPlayerItemStallEvent {}
impl PNSSecureCoding for AVMetricPlayerItemStallEvent {}
impl INSObject for AVMetricPlayerItemStallEvent {}
impl PNSObject for AVMetricPlayerItemStallEvent {}
impl IAVMetricPlayerItemStallEvent for AVMetricPlayerItemStallEvent {}
pub trait IAVMetricPlayerItemStallEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemStallEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemSeekEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemSeekEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemSeekEvent {}
impl AVMetricPlayerItemSeekEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekEvent").unwrap(), alloc) })
    }
}
impl IAVMetricPlayerItemRateChangeEvent for AVMetricPlayerItemSeekEvent {}
impl std::convert::TryFrom<AVMetricPlayerItemRateChangeEvent> for AVMetricPlayerItemSeekEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricPlayerItemRateChangeEvent,
    ) -> Result<AVMetricPlayerItemSeekEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekEvent").unwrap()) };
        if is_kind_of {
            Ok(AVMetricPlayerItemSeekEvent(parent.0))
        } else {
            Err ("This AVMetricPlayerItemRateChangeEvent cannot be downcasted to AVMetricPlayerItemSeekEvent" ,)
        }
    }
}
impl IAVMetricEvent for AVMetricPlayerItemSeekEvent {}
impl PNSSecureCoding for AVMetricPlayerItemSeekEvent {}
impl INSObject for AVMetricPlayerItemSeekEvent {}
impl PNSObject for AVMetricPlayerItemSeekEvent {}
impl IAVMetricPlayerItemSeekEvent for AVMetricPlayerItemSeekEvent {}
pub trait IAVMetricPlayerItemSeekEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemSeekDidCompleteEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemSeekDidCompleteEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemSeekDidCompleteEvent {}
impl AVMetricPlayerItemSeekDidCompleteEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekDidCompleteEvent").unwrap(), alloc) })
    }
}
impl IAVMetricPlayerItemRateChangeEvent for AVMetricPlayerItemSeekDidCompleteEvent {}
impl std::convert::TryFrom<AVMetricPlayerItemRateChangeEvent>
    for AVMetricPlayerItemSeekDidCompleteEvent
{
    type Error = &'static str;
    fn try_from(
        parent: AVMetricPlayerItemRateChangeEvent,
    ) -> Result<AVMetricPlayerItemSeekDidCompleteEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekDidCompleteEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemSeekDidCompleteEvent(parent.0))
        } else {
            Err ("This AVMetricPlayerItemRateChangeEvent cannot be downcasted to AVMetricPlayerItemSeekDidCompleteEvent" ,)
        }
    }
}
impl IAVMetricEvent for AVMetricPlayerItemSeekDidCompleteEvent {}
impl PNSSecureCoding for AVMetricPlayerItemSeekDidCompleteEvent {}
impl INSObject for AVMetricPlayerItemSeekDidCompleteEvent {}
impl PNSObject for AVMetricPlayerItemSeekDidCompleteEvent {}
impl IAVMetricPlayerItemSeekDidCompleteEvent for AVMetricPlayerItemSeekDidCompleteEvent {}
pub trait IAVMetricPlayerItemSeekDidCompleteEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn didSeekInBuffer(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, didSeekInBuffer)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemSeekDidCompleteEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricMediaRendition(pub id);
impl std::ops::Deref for AVMetricMediaRendition {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricMediaRendition {}
impl AVMetricMediaRendition {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricMediaRendition").unwrap(), alloc) })
    }
}
impl PNSSecureCoding for AVMetricMediaRendition {}
impl INSObject for AVMetricMediaRendition {}
impl PNSObject for AVMetricMediaRendition {}
impl std::convert::TryFrom<NSObject> for AVMetricMediaRendition {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetricMediaRendition, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricMediaRendition").unwrap()) };
        if is_kind_of {
            Ok(AVMetricMediaRendition(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetricMediaRendition")
        }
    }
}
impl IAVMetricMediaRendition for AVMetricMediaRendition {}
pub trait IAVMetricMediaRendition: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn stableID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stableID)
    }
    unsafe fn URL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URL)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricMediaRendition").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemVariantSwitchEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemVariantSwitchEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemVariantSwitchEvent {}
impl AVMetricPlayerItemVariantSwitchEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricPlayerItemVariantSwitchEvent {}
impl PNSSecureCoding for AVMetricPlayerItemVariantSwitchEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricPlayerItemVariantSwitchEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricEvent,
    ) -> Result<AVMetricPlayerItemVariantSwitchEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemVariantSwitchEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricPlayerItemVariantSwitchEvent")
        }
    }
}
impl INSObject for AVMetricPlayerItemVariantSwitchEvent {}
impl PNSObject for AVMetricPlayerItemVariantSwitchEvent {}
impl IAVMetricPlayerItemVariantSwitchEvent for AVMetricPlayerItemVariantSwitchEvent {}
pub trait IAVMetricPlayerItemVariantSwitchEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn fromVariant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, fromVariant)
    }
    unsafe fn toVariant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, toVariant)
    }
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn videoRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRendition)
    }
    unsafe fn audioRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioRendition)
    }
    unsafe fn subtitleRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, subtitleRendition)
    }
    unsafe fn didSucceed(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, didSucceed)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemVariantSwitchStartEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemVariantSwitchStartEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemVariantSwitchStartEvent {}
impl AVMetricPlayerItemVariantSwitchStartEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchStartEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricPlayerItemVariantSwitchStartEvent {}
impl PNSSecureCoding for AVMetricPlayerItemVariantSwitchStartEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricPlayerItemVariantSwitchStartEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricEvent,
    ) -> Result<AVMetricPlayerItemVariantSwitchStartEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchStartEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemVariantSwitchStartEvent(parent.0))
        } else {
            Err ("This AVMetricEvent cannot be downcasted to AVMetricPlayerItemVariantSwitchStartEvent" ,)
        }
    }
}
impl INSObject for AVMetricPlayerItemVariantSwitchStartEvent {}
impl PNSObject for AVMetricPlayerItemVariantSwitchStartEvent {}
impl IAVMetricPlayerItemVariantSwitchStartEvent for AVMetricPlayerItemVariantSwitchStartEvent {}
pub trait IAVMetricPlayerItemVariantSwitchStartEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn fromVariant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, fromVariant)
    }
    unsafe fn toVariant(&self) -> AVAssetVariant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, toVariant)
    }
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn videoRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRendition)
    }
    unsafe fn audioRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioRendition)
    }
    unsafe fn subtitleRendition(&self) -> AVMetricMediaRendition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, subtitleRendition)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemVariantSwitchStartEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricPlayerItemPlaybackSummaryEvent(pub id);
impl std::ops::Deref for AVMetricPlayerItemPlaybackSummaryEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricPlayerItemPlaybackSummaryEvent {}
impl AVMetricPlayerItemPlaybackSummaryEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemPlaybackSummaryEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricPlayerItemPlaybackSummaryEvent {}
impl PNSSecureCoding for AVMetricPlayerItemPlaybackSummaryEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricPlayerItemPlaybackSummaryEvent {
    type Error = &'static str;
    fn try_from(
        parent: AVMetricEvent,
    ) -> Result<AVMetricPlayerItemPlaybackSummaryEvent, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricPlayerItemPlaybackSummaryEvent").unwrap())
        };
        if is_kind_of {
            Ok(AVMetricPlayerItemPlaybackSummaryEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricPlayerItemPlaybackSummaryEvent")
        }
    }
}
impl INSObject for AVMetricPlayerItemPlaybackSummaryEvent {}
impl PNSObject for AVMetricPlayerItemPlaybackSummaryEvent {}
impl IAVMetricPlayerItemPlaybackSummaryEvent for AVMetricPlayerItemPlaybackSummaryEvent {}
pub trait IAVMetricPlayerItemPlaybackSummaryEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn errorEvent(&self) -> AVMetricErrorEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorEvent)
    }
    unsafe fn recoverableErrorCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recoverableErrorCount)
    }
    unsafe fn stallCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stallCount)
    }
    unsafe fn variantSwitchCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variantSwitchCount)
    }
    unsafe fn playbackDuration(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackDuration)
    }
    unsafe fn mediaResourceRequestCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaResourceRequestCount)
    }
    unsafe fn timeSpentRecoveringFromStall(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeSpentRecoveringFromStall)
    }
    unsafe fn timeSpentInInitialStartup(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeSpentInInitialStartup)
    }
    unsafe fn timeWeightedAverageBitrate(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeWeightedAverageBitrate)
    }
    unsafe fn timeWeightedPeakBitrate(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeWeightedPeakBitrate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricPlayerItemPlaybackSummaryEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetricDownloadSummaryEvent(pub id);
impl std::ops::Deref for AVMetricDownloadSummaryEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetricDownloadSummaryEvent {}
impl AVMetricDownloadSummaryEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricDownloadSummaryEvent").unwrap(), alloc) })
    }
}
impl IAVMetricEvent for AVMetricDownloadSummaryEvent {}
impl PNSSecureCoding for AVMetricDownloadSummaryEvent {}
impl std::convert::TryFrom<AVMetricEvent> for AVMetricDownloadSummaryEvent {
    type Error = &'static str;
    fn try_from(parent: AVMetricEvent) -> Result<AVMetricDownloadSummaryEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetricDownloadSummaryEvent").unwrap()) };
        if is_kind_of {
            Ok(AVMetricDownloadSummaryEvent(parent.0))
        } else {
            Err("This AVMetricEvent cannot be downcasted to AVMetricDownloadSummaryEvent")
        }
    }
}
impl INSObject for AVMetricDownloadSummaryEvent {}
impl PNSObject for AVMetricDownloadSummaryEvent {}
impl IAVMetricDownloadSummaryEvent for AVMetricDownloadSummaryEvent {}
pub trait IAVMetricDownloadSummaryEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn errorEvent(&self) -> AVMetricErrorEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorEvent)
    }
    unsafe fn recoverableErrorCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recoverableErrorCount)
    }
    unsafe fn mediaResourceRequestCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaResourceRequestCount)
    }
    unsafe fn bytesDownloadedCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bytesDownloadedCount)
    }
    unsafe fn downloadDuration(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, downloadDuration)
    }
    unsafe fn variants(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variants)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetricDownloadSummaryEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerMediaSelectionCriteria(pub id);
impl std::ops::Deref for AVPlayerMediaSelectionCriteria {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerMediaSelectionCriteria {}
impl AVPlayerMediaSelectionCriteria {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerMediaSelectionCriteria").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerMediaSelectionCriteria {}
impl PNSObject for AVPlayerMediaSelectionCriteria {}
impl std::convert::TryFrom<NSObject> for AVPlayerMediaSelectionCriteria {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerMediaSelectionCriteria, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerMediaSelectionCriteria").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerMediaSelectionCriteria(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerMediaSelectionCriteria")
        }
    }
}
impl IAVPlayerMediaSelectionCriteria for AVPlayerMediaSelectionCriteria {}
pub trait IAVPlayerMediaSelectionCriteria: Sized + std::ops::Deref {
    unsafe fn initWithPreferredLanguages_preferredMediaCharacteristics_(
        &self,
        preferredLanguages: NSArray,
        preferredMediaCharacteristics: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPreferredLanguages : preferredLanguages, preferredMediaCharacteristics : preferredMediaCharacteristics)
    }
    unsafe fn initWithPrincipalMediaCharacteristics_preferredLanguages_preferredMediaCharacteristics_(
        &self,
        principalMediaCharacteristics: NSArray,
        preferredLanguages: NSArray,
        preferredMediaCharacteristics: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPrincipalMediaCharacteristics : principalMediaCharacteristics, preferredLanguages : preferredLanguages, preferredMediaCharacteristics : preferredMediaCharacteristics)
    }
    unsafe fn preferredLanguages(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredLanguages)
    }
    unsafe fn preferredMediaCharacteristics(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaCharacteristics)
    }
    unsafe fn principalMediaCharacteristics(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, principalMediaCharacteristics)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadTask(pub id);
impl std::ops::Deref for AVAssetDownloadTask {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadTask {}
impl AVAssetDownloadTask {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadTask").unwrap(), alloc) })
    }
}
impl INSURLSessionTask for AVAssetDownloadTask {}
impl PNSCopying for AVAssetDownloadTask {}
impl PNSProgressReporting for AVAssetDownloadTask {}
impl std::convert::TryFrom<NSURLSessionTask> for AVAssetDownloadTask {
    type Error = &'static str;
    fn try_from(parent: NSURLSessionTask) -> Result<AVAssetDownloadTask, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadTask").unwrap()) };
        if is_kind_of {
            Ok(AVAssetDownloadTask(parent.0))
        } else {
            Err("This NSURLSessionTask cannot be downcasted to AVAssetDownloadTask")
        }
    }
}
impl INSObject for AVAssetDownloadTask {}
impl PNSObject for AVAssetDownloadTask {}
impl IAVAssetDownloadTask for AVAssetDownloadTask {}
pub trait IAVAssetDownloadTask: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn URLAsset(&self) -> AVURLAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URLAsset)
    }
    unsafe fn destinationURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, destinationURL)
    }
    unsafe fn options(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, options)
    }
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn originalRequest(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, originalRequest)
    }
    unsafe fn currentRequest(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentRequest)
    }
    unsafe fn response(&self) -> NSURLResponse
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, response)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadTask").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadConfiguration(pub id);
impl std::ops::Deref for AVAssetDownloadConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadConfiguration {}
impl AVAssetDownloadConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadConfiguration").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetDownloadConfiguration {}
impl PNSObject for AVAssetDownloadConfiguration {}
impl std::convert::TryFrom<NSObject> for AVAssetDownloadConfiguration {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetDownloadConfiguration, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadConfiguration").unwrap()) };
        if is_kind_of {
            Ok(AVAssetDownloadConfiguration(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetDownloadConfiguration")
        }
    }
}
impl IAVAssetDownloadConfiguration for AVAssetDownloadConfiguration {}
pub trait IAVAssetDownloadConfiguration: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setInterstitialMediaSelectionCriteria_forMediaCharacteristic_(
        &self,
        criteria: NSArray,
        mediaCharacteristic: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInterstitialMediaSelectionCriteria : criteria, forMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn artworkData(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, artworkData)
    }
    unsafe fn setArtworkData_(&self, artworkData: NSData)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setArtworkData : artworkData)
    }
    unsafe fn primaryContentConfiguration(&self) -> AVAssetDownloadContentConfiguration
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryContentConfiguration)
    }
    unsafe fn auxiliaryContentConfigurations(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, auxiliaryContentConfigurations)
    }
    unsafe fn setAuxiliaryContentConfigurations_(&self, auxiliaryContentConfigurations: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAuxiliaryContentConfigurations : auxiliaryContentConfigurations)
    }
    unsafe fn optimizesAuxiliaryContentConfigurations(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, optimizesAuxiliaryContentConfigurations)
    }
    unsafe fn setOptimizesAuxiliaryContentConfigurations_(
        &self,
        optimizesAuxiliaryContentConfigurations: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOptimizesAuxiliaryContentConfigurations : optimizesAuxiliaryContentConfigurations)
    }
    unsafe fn downloadsInterstitialAssets(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, downloadsInterstitialAssets)
    }
    unsafe fn setDownloadsInterstitialAssets_(&self, downloadsInterstitialAssets: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDownloadsInterstitialAssets : downloadsInterstitialAssets)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadConfiguration").unwrap(), new)
    }
    unsafe fn downloadConfigurationWithAsset_title_(
        asset: AVURLAsset,
        title: NSString,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadConfiguration").unwrap(), downloadConfigurationWithAsset : asset, title : title)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadContentConfiguration(pub id);
impl std::ops::Deref for AVAssetDownloadContentConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadContentConfiguration {}
impl AVAssetDownloadContentConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadContentConfiguration").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAssetDownloadContentConfiguration {}
impl INSObject for AVAssetDownloadContentConfiguration {}
impl PNSObject for AVAssetDownloadContentConfiguration {}
impl std::convert::TryFrom<NSObject> for AVAssetDownloadContentConfiguration {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetDownloadContentConfiguration, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadContentConfiguration").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetDownloadContentConfiguration(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetDownloadContentConfiguration")
        }
    }
}
impl IAVAssetDownloadContentConfiguration for AVAssetDownloadContentConfiguration {}
pub trait IAVAssetDownloadContentConfiguration: Sized + std::ops::Deref {
    unsafe fn variantQualifiers(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variantQualifiers)
    }
    unsafe fn setVariantQualifiers_(&self, variantQualifiers: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVariantQualifiers : variantQualifiers)
    }
    unsafe fn mediaSelections(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaSelections)
    }
    unsafe fn setMediaSelections_(&self, mediaSelections: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMediaSelections : mediaSelections)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAggregateAssetDownloadTask(pub id);
impl std::ops::Deref for AVAggregateAssetDownloadTask {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAggregateAssetDownloadTask {}
impl AVAggregateAssetDownloadTask {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAggregateAssetDownloadTask").unwrap(), alloc) })
    }
}
impl INSURLSessionTask for AVAggregateAssetDownloadTask {}
impl PNSCopying for AVAggregateAssetDownloadTask {}
impl PNSProgressReporting for AVAggregateAssetDownloadTask {}
impl std::convert::TryFrom<NSURLSessionTask> for AVAggregateAssetDownloadTask {
    type Error = &'static str;
    fn try_from(parent: NSURLSessionTask) -> Result<AVAggregateAssetDownloadTask, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAggregateAssetDownloadTask").unwrap()) };
        if is_kind_of {
            Ok(AVAggregateAssetDownloadTask(parent.0))
        } else {
            Err("This NSURLSessionTask cannot be downcasted to AVAggregateAssetDownloadTask")
        }
    }
}
impl INSObject for AVAggregateAssetDownloadTask {}
impl PNSObject for AVAggregateAssetDownloadTask {}
impl IAVAggregateAssetDownloadTask for AVAggregateAssetDownloadTask {}
pub trait IAVAggregateAssetDownloadTask: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn URLAsset(&self) -> AVURLAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URLAsset)
    }
    unsafe fn originalRequest(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, originalRequest)
    }
    unsafe fn currentRequest(&self) -> NSURLRequest
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentRequest)
    }
    unsafe fn response(&self) -> NSURLResponse
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, response)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAggregateAssetDownloadTask").unwrap(), new)
    }
}
pub trait PAVAssetDownloadDelegate: Sized + std::ops::Deref {
    unsafe fn URLSession_assetDownloadTask_didFinishDownloadingToURL_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        location: NSURL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, didFinishDownloadingToURL : location)
    }
    unsafe fn URLSession_assetDownloadTask_didLoadTimeRange_totalTimeRangesLoaded_timeRangeExpectedToLoad_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        timeRange: CMTimeRange,
        loadedTimeRanges: NSArray,
        timeRangeExpectedToLoad: CMTimeRange,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, didLoadTimeRange : timeRange, totalTimeRangesLoaded : loadedTimeRanges, timeRangeExpectedToLoad : timeRangeExpectedToLoad)
    }
    unsafe fn URLSession_assetDownloadTask_didResolveMediaSelection_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        resolvedMediaSelection: AVMediaSelection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, didResolveMediaSelection : resolvedMediaSelection)
    }
    unsafe fn URLSession_assetDownloadTask_willDownloadToURL_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        location: NSURL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, willDownloadToURL : location)
    }
    unsafe fn URLSession_aggregateAssetDownloadTask_willDownloadToURL_(
        &self,
        session: NSURLSession,
        aggregateAssetDownloadTask: AVAggregateAssetDownloadTask,
        location: NSURL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, aggregateAssetDownloadTask : aggregateAssetDownloadTask, willDownloadToURL : location)
    }
    unsafe fn URLSession_aggregateAssetDownloadTask_didCompleteForMediaSelection_(
        &self,
        session: NSURLSession,
        aggregateAssetDownloadTask: AVAggregateAssetDownloadTask,
        mediaSelection: AVMediaSelection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, aggregateAssetDownloadTask : aggregateAssetDownloadTask, didCompleteForMediaSelection : mediaSelection)
    }
    unsafe fn URLSession_aggregateAssetDownloadTask_didLoadTimeRange_totalTimeRangesLoaded_timeRangeExpectedToLoad_forMediaSelection_(
        &self,
        session: NSURLSession,
        aggregateAssetDownloadTask: AVAggregateAssetDownloadTask,
        timeRange: CMTimeRange,
        loadedTimeRanges: NSArray,
        timeRangeExpectedToLoad: CMTimeRange,
        mediaSelection: AVMediaSelection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, aggregateAssetDownloadTask : aggregateAssetDownloadTask, didLoadTimeRange : timeRange, totalTimeRangesLoaded : loadedTimeRanges, timeRangeExpectedToLoad : timeRangeExpectedToLoad, forMediaSelection : mediaSelection)
    }
    unsafe fn URLSession_assetDownloadTask_willDownloadVariants_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        variants: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, willDownloadVariants : variants)
    }
    unsafe fn URLSession_assetDownloadTask_didReceiveMetricEvent_(
        &self,
        session: NSURLSession,
        assetDownloadTask: AVAssetDownloadTask,
        metricEvent: AVMetricEvent,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, URLSession : session, assetDownloadTask : assetDownloadTask, didReceiveMetricEvent : metricEvent)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadURLSession(pub id);
impl std::ops::Deref for AVAssetDownloadURLSession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadURLSession {}
impl AVAssetDownloadURLSession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), alloc) })
    }
}
impl INSURLSession for AVAssetDownloadURLSession {}
impl std::convert::TryFrom<NSURLSession> for AVAssetDownloadURLSession {
    type Error = &'static str;
    fn try_from(parent: NSURLSession) -> Result<AVAssetDownloadURLSession, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap()) };
        if is_kind_of {
            Ok(AVAssetDownloadURLSession(parent.0))
        } else {
            Err("This NSURLSession cannot be downcasted to AVAssetDownloadURLSession")
        }
    }
}
impl INSObject for AVAssetDownloadURLSession {}
impl PNSObject for AVAssetDownloadURLSession {}
impl IAVAssetDownloadURLSession for AVAssetDownloadURLSession {}
pub trait IAVAssetDownloadURLSession: Sized + std::ops::Deref {
    unsafe fn assetDownloadTaskWithURLAsset_destinationURL_options_(
        &self,
        URLAsset: AVURLAsset,
        destinationURL: NSURL,
        options: NSDictionary,
    ) -> AVAssetDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, assetDownloadTaskWithURLAsset : URLAsset, destinationURL : destinationURL, options : options)
    }
    unsafe fn assetDownloadTaskWithURLAsset_assetTitle_assetArtworkData_options_(
        &self,
        URLAsset: AVURLAsset,
        title: NSString,
        artworkData: NSData,
        options: NSDictionary,
    ) -> AVAssetDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, assetDownloadTaskWithURLAsset : URLAsset, assetTitle : title, assetArtworkData : artworkData, options : options)
    }
    unsafe fn aggregateAssetDownloadTaskWithURLAsset_mediaSelections_assetTitle_assetArtworkData_options_(
        &self,
        URLAsset: AVURLAsset,
        mediaSelections: NSArray,
        title: NSString,
        artworkData: NSData,
        options: NSDictionary,
    ) -> AVAggregateAssetDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, aggregateAssetDownloadTaskWithURLAsset : URLAsset, mediaSelections : mediaSelections, assetTitle : title, assetArtworkData : artworkData, options : options)
    }
    unsafe fn assetDownloadTaskWithConfiguration_(
        &self,
        downloadConfiguration: AVAssetDownloadConfiguration,
    ) -> AVAssetDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, assetDownloadTaskWithConfiguration : downloadConfiguration)
    }
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn dataTaskWithRequest_(&self, request: NSURLRequest) -> NSURLSessionDataTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dataTaskWithRequest : request)
    }
    unsafe fn dataTaskWithURL_(&self, url: NSURL) -> NSURLSessionDataTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dataTaskWithURL : url)
    }
    unsafe fn uploadTaskWithRequest_fromFile_(
        &self,
        request: NSURLRequest,
        fileURL: NSURL,
    ) -> NSURLSessionUploadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, uploadTaskWithRequest : request, fromFile : fileURL)
    }
    unsafe fn uploadTaskWithRequest_fromData_(
        &self,
        request: NSURLRequest,
        bodyData: NSData,
    ) -> NSURLSessionUploadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, uploadTaskWithRequest : request, fromData : bodyData)
    }
    unsafe fn uploadTaskWithStreamedRequest_(&self, request: NSURLRequest) -> NSURLSessionUploadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, uploadTaskWithStreamedRequest : request)
    }
    unsafe fn downloadTaskWithRequest_(&self, request: NSURLRequest) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithRequest : request)
    }
    unsafe fn downloadTaskWithURL_(&self, url: NSURL) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithURL : url)
    }
    unsafe fn downloadTaskWithResumeData_(&self, resumeData: NSData) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithResumeData : resumeData)
    }
    unsafe fn dataTaskWithRequest_completionHandler_(
        &self,
        request: NSURLRequest,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionDataTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dataTaskWithRequest : request, completionHandler : completionHandler)
    }
    unsafe fn dataTaskWithURL_completionHandler_(
        &self,
        url: NSURL,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionDataTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dataTaskWithURL : url, completionHandler : completionHandler)
    }
    unsafe fn uploadTaskWithRequest_fromFile_completionHandler_(
        &self,
        request: NSURLRequest,
        fileURL: NSURL,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionUploadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, uploadTaskWithRequest : request, fromFile : fileURL, completionHandler : completionHandler)
    }
    unsafe fn uploadTaskWithRequest_fromData_completionHandler_(
        &self,
        request: NSURLRequest,
        bodyData: NSData,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionUploadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, uploadTaskWithRequest : request, fromData : bodyData, completionHandler : completionHandler)
    }
    unsafe fn downloadTaskWithRequest_completionHandler_(
        &self,
        request: NSURLRequest,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithRequest : request, completionHandler : completionHandler)
    }
    unsafe fn downloadTaskWithURL_completionHandler_(
        &self,
        url: NSURL,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithURL : url, completionHandler : completionHandler)
    }
    unsafe fn downloadTaskWithResumeData_completionHandler_(
        &self,
        resumeData: NSData,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> NSURLSessionDownloadTask
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, downloadTaskWithResumeData : resumeData, completionHandler : completionHandler)
    }
    unsafe fn sessionWithConfiguration_assetDownloadDelegate_delegateQueue_(
        configuration: NSURLSessionConfiguration,
        delegate: *mut u64,
        delegateQueue: NSOperationQueue,
    ) -> AVAssetDownloadURLSession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), sessionWithConfiguration : configuration, assetDownloadDelegate : delegate, delegateQueue : delegateQueue)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), new)
    }
    unsafe fn sharedSession() -> NSURLSession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), sharedSession)
    }
    unsafe fn sessionWithConfiguration_(configuration: NSURLSessionConfiguration) -> NSURLSession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), sessionWithConfiguration : configuration)
    }
    unsafe fn sessionWithConfiguration_delegate_delegateQueue_(
        configuration: NSURLSessionConfiguration,
        delegate: *mut u64,
        queue: NSOperationQueue,
    ) -> NSURLSession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadURLSession").unwrap(), sessionWithConfiguration : configuration, delegate : delegate, delegateQueue : queue)
    }
}
pub type AVAssetDownloadedAssetEvictionPriority = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadStorageManager(pub id);
impl std::ops::Deref for AVAssetDownloadStorageManager {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadStorageManager {}
impl AVAssetDownloadStorageManager {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadStorageManager").unwrap(), alloc) })
    }
}
impl INSObject for AVAssetDownloadStorageManager {}
impl PNSObject for AVAssetDownloadStorageManager {}
impl std::convert::TryFrom<NSObject> for AVAssetDownloadStorageManager {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetDownloadStorageManager, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadStorageManager").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetDownloadStorageManager(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetDownloadStorageManager")
        }
    }
}
impl IAVAssetDownloadStorageManager for AVAssetDownloadStorageManager {}
pub trait IAVAssetDownloadStorageManager: Sized + std::ops::Deref {
    unsafe fn setStorageManagementPolicy_forURL_(
        &self,
        storageManagementPolicy: AVAssetDownloadStorageManagementPolicy,
        downloadStorageURL: NSURL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setStorageManagementPolicy : storageManagementPolicy, forURL : downloadStorageURL)
    }
    unsafe fn storageManagementPolicyForURL_(
        &self,
        downloadStorageURL: NSURL,
    ) -> AVAssetDownloadStorageManagementPolicy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, storageManagementPolicyForURL : downloadStorageURL)
    }
    unsafe fn sharedDownloadStorageManager() -> AVAssetDownloadStorageManager
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadStorageManager").unwrap(), sharedDownloadStorageManager)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVAssetDownloadStorageManagementPolicy(pub id);
impl std::ops::Deref for AVAssetDownloadStorageManagementPolicy {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVAssetDownloadStorageManagementPolicy {}
impl AVAssetDownloadStorageManagementPolicy {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVAssetDownloadStorageManagementPolicy").unwrap(), alloc) })
    }
}
impl PNSCopying for AVAssetDownloadStorageManagementPolicy {}
impl PNSMutableCopying for AVAssetDownloadStorageManagementPolicy {}
impl INSObject for AVAssetDownloadStorageManagementPolicy {}
impl PNSObject for AVAssetDownloadStorageManagementPolicy {}
impl std::convert::TryFrom<NSObject> for AVAssetDownloadStorageManagementPolicy {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVAssetDownloadStorageManagementPolicy, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVAssetDownloadStorageManagementPolicy").unwrap())
        };
        if is_kind_of {
            Ok(AVAssetDownloadStorageManagementPolicy(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVAssetDownloadStorageManagementPolicy")
        }
    }
}
impl IAVAssetDownloadStorageManagementPolicy for AVAssetDownloadStorageManagementPolicy {}
pub trait IAVAssetDownloadStorageManagementPolicy: Sized + std::ops::Deref {
    unsafe fn priority(&self) -> AVAssetDownloadedAssetEvictionPriority
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, priority)
    }
    unsafe fn expirationDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expirationDate)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableAssetDownloadStorageManagementPolicy(pub id);
impl std::ops::Deref for AVMutableAssetDownloadStorageManagementPolicy {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableAssetDownloadStorageManagementPolicy {}
impl AVMutableAssetDownloadStorageManagementPolicy {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableAssetDownloadStorageManagementPolicy").unwrap(), alloc) })
    }
}
impl IAVAssetDownloadStorageManagementPolicy for AVMutableAssetDownloadStorageManagementPolicy {}
impl PNSCopying for AVMutableAssetDownloadStorageManagementPolicy {}
impl PNSMutableCopying for AVMutableAssetDownloadStorageManagementPolicy {}
impl From<AVMutableAssetDownloadStorageManagementPolicy>
    for AVAssetDownloadStorageManagementPolicy
{
    fn from(
        child: AVMutableAssetDownloadStorageManagementPolicy,
    ) -> AVAssetDownloadStorageManagementPolicy {
        AVAssetDownloadStorageManagementPolicy(child.0)
    }
}
impl std::convert::TryFrom<AVAssetDownloadStorageManagementPolicy>
    for AVMutableAssetDownloadStorageManagementPolicy
{
    type Error = &'static str;
    fn try_from(
        parent: AVAssetDownloadStorageManagementPolicy,
    ) -> Result<AVMutableAssetDownloadStorageManagementPolicy, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableAssetDownloadStorageManagementPolicy").unwrap())
        };
        if is_kind_of {
            Ok(AVMutableAssetDownloadStorageManagementPolicy(parent.0))
        } else {
            Err ("This AVAssetDownloadStorageManagementPolicy cannot be downcasted to AVMutableAssetDownloadStorageManagementPolicy" ,)
        }
    }
}
impl INSObject for AVMutableAssetDownloadStorageManagementPolicy {}
impl PNSObject for AVMutableAssetDownloadStorageManagementPolicy {}
impl IAVMutableAssetDownloadStorageManagementPolicy
    for AVMutableAssetDownloadStorageManagementPolicy
{
}
pub trait IAVMutableAssetDownloadStorageManagementPolicy: Sized + std::ops::Deref {
    unsafe fn priority(&self) -> AVAssetDownloadedAssetEvictionPriority
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, priority)
    }
    unsafe fn setPriority_(&self, priority: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPriority : priority)
    }
    unsafe fn expirationDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expirationDate)
    }
    unsafe fn setExpirationDate_(&self, expirationDate: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExpirationDate : expirationDate)
    }
}
pub type AVCaptionUnitsType = NSInteger;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionDimension {
    pub value: CGFloat,
    pub units: AVCaptionUnitsType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionPoint {
    pub x: AVCaptionDimension,
    pub y: AVCaptionDimension,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionSize {
    pub width: AVCaptionDimension,
    pub height: AVCaptionDimension,
}
pub type AVCaptionRegionDisplayAlignment = NSInteger;
pub type AVCaptionRegionWritingMode = NSInteger;
pub type AVCaptionRegionScroll = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionRegion(pub id);
impl std::ops::Deref for AVCaptionRegion {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionRegion {}
impl AVCaptionRegion {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCaptionRegion {}
impl PNSMutableCopying for AVCaptionRegion {}
impl PNSSecureCoding for AVCaptionRegion {}
impl INSObject for AVCaptionRegion {}
impl PNSObject for AVCaptionRegion {}
impl std::convert::TryFrom<NSObject> for AVCaptionRegion {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionRegion, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionRegion(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionRegion")
        }
    }
}
impl IAVCaptionRegion for AVCaptionRegion {}
pub trait IAVCaptionRegion: Sized + std::ops::Deref {
    unsafe fn encodeWithCoder_(&self, encoder: NSCoder)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, encodeWithCoder : encoder)
    }
    unsafe fn isEqual_(&self, object: id) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isEqual : object)
    }
    unsafe fn mutableCopyWithZone_(&self, zone: *mut NSZone) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mutableCopyWithZone : zone)
    }
    unsafe fn identifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn origin(&self) -> AVCaptionPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, origin)
    }
    unsafe fn size(&self) -> AVCaptionSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, size)
    }
    unsafe fn scroll(&self) -> AVCaptionRegionScroll
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, scroll)
    }
    unsafe fn displayAlignment(&self) -> AVCaptionRegionDisplayAlignment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayAlignment)
    }
    unsafe fn writingMode(&self) -> AVCaptionRegionWritingMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, writingMode)
    }
    unsafe fn appleITTTopRegion() -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), appleITTTopRegion)
    }
    unsafe fn appleITTBottomRegion() -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), appleITTBottomRegion)
    }
    unsafe fn appleITTLeftRegion() -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), appleITTLeftRegion)
    }
    unsafe fn appleITTRightRegion() -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), appleITTRightRegion)
    }
    unsafe fn subRipTextBottomRegion() -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRegion").unwrap(), subRipTextBottomRegion)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableCaptionRegion(pub id);
impl std::ops::Deref for AVMutableCaptionRegion {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableCaptionRegion {}
impl AVMutableCaptionRegion {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableCaptionRegion").unwrap(), alloc) })
    }
}
impl IAVCaptionRegion for AVMutableCaptionRegion {}
impl PNSCopying for AVMutableCaptionRegion {}
impl PNSMutableCopying for AVMutableCaptionRegion {}
impl PNSSecureCoding for AVMutableCaptionRegion {}
impl From<AVMutableCaptionRegion> for AVCaptionRegion {
    fn from(child: AVMutableCaptionRegion) -> AVCaptionRegion {
        AVCaptionRegion(child.0)
    }
}
impl std::convert::TryFrom<AVCaptionRegion> for AVMutableCaptionRegion {
    type Error = &'static str;
    fn try_from(parent: AVCaptionRegion) -> Result<AVMutableCaptionRegion, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableCaptionRegion").unwrap()) };
        if is_kind_of {
            Ok(AVMutableCaptionRegion(parent.0))
        } else {
            Err("This AVCaptionRegion cannot be downcasted to AVMutableCaptionRegion")
        }
    }
}
impl INSObject for AVMutableCaptionRegion {}
impl PNSObject for AVMutableCaptionRegion {}
impl IAVMutableCaptionRegion for AVMutableCaptionRegion {}
pub trait IAVMutableCaptionRegion: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithIdentifier_(&self, identifier: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithIdentifier : identifier)
    }
    unsafe fn origin(&self) -> AVCaptionPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, origin)
    }
    unsafe fn setOrigin_(&self, origin: AVCaptionPoint)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOrigin : origin)
    }
    unsafe fn size(&self) -> AVCaptionSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, size)
    }
    unsafe fn setSize_(&self, size: AVCaptionSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSize : size)
    }
    unsafe fn scroll(&self) -> AVCaptionRegionScroll
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, scroll)
    }
    unsafe fn setScroll_(&self, scroll: AVCaptionRegionScroll)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setScroll : scroll)
    }
    unsafe fn displayAlignment(&self) -> AVCaptionRegionDisplayAlignment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayAlignment)
    }
    unsafe fn setDisplayAlignment_(&self, displayAlignment: AVCaptionRegionDisplayAlignment)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDisplayAlignment : displayAlignment)
    }
    unsafe fn writingMode(&self) -> AVCaptionRegionWritingMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, writingMode)
    }
    unsafe fn setWritingMode_(&self, writingMode: AVCaptionRegionWritingMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWritingMode : writingMode)
    }
}
pub type AVCaptionAnimation = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaption(pub id);
impl std::ops::Deref for AVCaption {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaption {}
impl AVCaption {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaption").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCaption {}
impl PNSMutableCopying for AVCaption {}
impl PNSSecureCoding for AVCaption {}
impl INSObject for AVCaption {}
impl PNSObject for AVCaption {}
impl std::convert::TryFrom<NSObject> for AVCaption {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaption, Self::Error> {
        let is_kind_of: bool = unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaption").unwrap()) };
        if is_kind_of {
            Ok(AVCaption(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaption")
        }
    }
}
impl IAVCaption for AVCaption {}
pub trait IAVCaption: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithText_timeRange_(&self, text: NSString, timeRange: CMTimeRange) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithText : text, timeRange : timeRange)
    }
    unsafe fn text(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, text)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaption").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableCaption(pub id);
impl std::ops::Deref for AVMutableCaption {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableCaption {}
impl AVMutableCaption {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableCaption").unwrap(), alloc) })
    }
}
impl IAVCaption for AVMutableCaption {}
impl PNSCopying for AVMutableCaption {}
impl PNSMutableCopying for AVMutableCaption {}
impl PNSSecureCoding for AVMutableCaption {}
impl From<AVMutableCaption> for AVCaption {
    fn from(child: AVMutableCaption) -> AVCaption {
        AVCaption(child.0)
    }
}
impl std::convert::TryFrom<AVCaption> for AVMutableCaption {
    type Error = &'static str;
    fn try_from(parent: AVCaption) -> Result<AVMutableCaption, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableCaption").unwrap()) };
        if is_kind_of {
            Ok(AVMutableCaption(parent.0))
        } else {
            Err("This AVCaption cannot be downcasted to AVMutableCaption")
        }
    }
}
impl INSObject for AVMutableCaption {}
impl PNSObject for AVMutableCaption {}
impl IAVMutableCaption for AVMutableCaption {}
pub trait IAVMutableCaption: Sized + std::ops::Deref {
    unsafe fn text(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, text)
    }
    unsafe fn setText_(&self, text: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setText : text)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn setTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimeRange : timeRange)
    }
}
pub type AVCaptionFontWeight = NSInteger;
pub type AVCaptionFontStyle = NSInteger;
pub type AVCaptionDecoration = NSUInteger;
pub type AVCaptionTextCombine = NSInteger;
pub type AVCaptionTextAlignment = NSInteger;
impl AVCaption_Styling for AVCaption {}
pub trait AVCaption_Styling: Sized + std::ops::Deref {
    unsafe fn textColorAtIndex_range_(&self, index: NSInteger, outRange: *mut NSRange) -> CGColorRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, textColorAtIndex : index, range : outRange)
    }
    unsafe fn backgroundColorAtIndex_range_(
        &self,
        index: NSInteger,
        outRange: *mut NSRange,
    ) -> CGColorRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, backgroundColorAtIndex : index, range : outRange)
    }
    unsafe fn fontWeightAtIndex_range_(
        &self,
        index: NSInteger,
        outRange: *mut NSRange,
    ) -> AVCaptionFontWeight
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, fontWeightAtIndex : index, range : outRange)
    }
    unsafe fn fontStyleAtIndex_range_(
        &self,
        index: NSInteger,
        outRange: *mut NSRange,
    ) -> AVCaptionFontStyle
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, fontStyleAtIndex : index, range : outRange)
    }
    unsafe fn decorationAtIndex_range_(
        &self,
        index: NSInteger,
        outRange: *mut NSRange,
    ) -> AVCaptionDecoration
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, decorationAtIndex : index, range : outRange)
    }
    unsafe fn textCombineAtIndex_range_(
        &self,
        index: NSInteger,
        outRange: *mut NSRange,
    ) -> AVCaptionTextCombine
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, textCombineAtIndex : index, range : outRange)
    }
    unsafe fn rubyAtIndex_range_(&self, index: NSInteger, outRange: *mut NSRange) -> AVCaptionRuby
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, rubyAtIndex : index, range : outRange)
    }
}
impl AVCaption_Region for AVCaption {}
pub trait AVCaption_Region: Sized + std::ops::Deref {
    unsafe fn region(&self) -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, region)
    }
    unsafe fn textAlignment(&self) -> AVCaptionTextAlignment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textAlignment)
    }
}
impl AVCaption_Animation for AVCaption {}
pub trait AVCaption_Animation: Sized + std::ops::Deref {
    unsafe fn animation(&self) -> AVCaptionAnimation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, animation)
    }
}
impl AVMutableCaption_Styling for AVMutableCaption {}
pub trait AVMutableCaption_Styling: Sized + std::ops::Deref {
    unsafe fn setTextColor_inRange_(&self, color: CGColorRef, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTextColor : color, inRange : range)
    }
    unsafe fn setBackgroundColor_inRange_(&self, color: CGColorRef, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setBackgroundColor : color, inRange : range)
    }
    unsafe fn setFontWeight_inRange_(&self, fontWeight: AVCaptionFontWeight, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFontWeight : fontWeight, inRange : range)
    }
    unsafe fn setFontStyle_inRange_(&self, fontStyle: AVCaptionFontStyle, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFontStyle : fontStyle, inRange : range)
    }
    unsafe fn setDecoration_inRange_(&self, decoration: AVCaptionDecoration, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDecoration : decoration, inRange : range)
    }
    unsafe fn setTextCombine_inRange_(&self, textCombine: AVCaptionTextCombine, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTextCombine : textCombine, inRange : range)
    }
    unsafe fn setRuby_inRange_(&self, ruby: AVCaptionRuby, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRuby : ruby, inRange : range)
    }
    unsafe fn removeTextColorInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTextColorInRange : range)
    }
    unsafe fn removeBackgroundColorInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeBackgroundColorInRange : range)
    }
    unsafe fn removeFontWeightInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeFontWeightInRange : range)
    }
    unsafe fn removeFontStyleInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeFontStyleInRange : range)
    }
    unsafe fn removeDecorationInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeDecorationInRange : range)
    }
    unsafe fn removeTextCombineInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTextCombineInRange : range)
    }
    unsafe fn removeRubyInRange_(&self, range: NSRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeRubyInRange : range)
    }
}
impl AVMutableCaption_Region for AVMutableCaption {}
pub trait AVMutableCaption_Region: Sized + std::ops::Deref {
    unsafe fn region(&self) -> AVCaptionRegion
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, region)
    }
    unsafe fn setRegion_(&self, region: AVCaptionRegion)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRegion : region)
    }
    unsafe fn textAlignment(&self) -> AVCaptionTextAlignment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textAlignment)
    }
    unsafe fn setTextAlignment_(&self, textAlignment: AVCaptionTextAlignment)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTextAlignment : textAlignment)
    }
}
impl AVMutableCaption_Animation for AVMutableCaption {}
pub trait AVMutableCaption_Animation: Sized + std::ops::Deref {
    unsafe fn animation(&self) -> AVCaptionAnimation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, animation)
    }
    unsafe fn setAnimation_(&self, animation: AVCaptionAnimation)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAnimation : animation)
    }
}
pub type AVCaptionRubyPosition = NSInteger;
pub type AVCaptionRubyAlignment = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionRuby(pub id);
impl std::ops::Deref for AVCaptionRuby {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionRuby {}
impl AVCaptionRuby {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRuby").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCaptionRuby {}
impl PNSSecureCoding for AVCaptionRuby {}
impl INSObject for AVCaptionRuby {}
impl PNSObject for AVCaptionRuby {}
impl std::convert::TryFrom<NSObject> for AVCaptionRuby {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionRuby, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionRuby").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionRuby(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionRuby")
        }
    }
}
impl IAVCaptionRuby for AVCaptionRuby {}
pub trait IAVCaptionRuby: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithText_(&self, text: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithText : text)
    }
    unsafe fn initWithText_position_alignment_(
        &self,
        text: NSString,
        position: AVCaptionRubyPosition,
        alignment: AVCaptionRubyAlignment,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithText : text, position : position, alignment : alignment)
    }
    unsafe fn text(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, text)
    }
    unsafe fn position(&self) -> AVCaptionRubyPosition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, position)
    }
    unsafe fn alignment(&self) -> AVCaptionRubyAlignment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alignment)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRuby").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionGroup(pub id);
impl std::ops::Deref for AVCaptionGroup {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionGroup {}
impl AVCaptionGroup {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionGroup").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionGroup {}
impl PNSObject for AVCaptionGroup {}
impl std::convert::TryFrom<NSObject> for AVCaptionGroup {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionGroup, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionGroup").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionGroup(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionGroup")
        }
    }
}
impl IAVCaptionGroup for AVCaptionGroup {}
pub trait IAVCaptionGroup: Sized + std::ops::Deref {
    unsafe fn initWithCaptions_timeRange_(
        &self,
        captions: NSArray,
        timeRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithCaptions : captions, timeRange : timeRange)
    }
    unsafe fn initWithTimeRange_(&self, timeRange: CMTimeRange) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTimeRange : timeRange)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn captions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, captions)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionGrouper(pub id);
impl std::ops::Deref for AVCaptionGrouper {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionGrouper {}
impl AVCaptionGrouper {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionGrouper").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionGrouper {}
impl PNSObject for AVCaptionGrouper {}
impl std::convert::TryFrom<NSObject> for AVCaptionGrouper {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionGrouper, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionGrouper").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionGrouper(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionGrouper")
        }
    }
}
impl IAVCaptionGrouper for AVCaptionGrouper {}
pub trait IAVCaptionGrouper: Sized + std::ops::Deref {
    unsafe fn addCaption_(&self, input: AVCaption)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addCaption : input)
    }
    unsafe fn flushAddedCaptionsIntoGroupsUpToTime_(&self, upToTime: CMTime) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, flushAddedCaptionsIntoGroupsUpToTime : upToTime)
    }
}
pub type AVCaptionConversionValidatorStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionConversionValidator(pub id);
impl std::ops::Deref for AVCaptionConversionValidator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionConversionValidator {}
impl AVCaptionConversionValidator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionValidator").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionConversionValidator {}
impl PNSObject for AVCaptionConversionValidator {}
impl std::convert::TryFrom<NSObject> for AVCaptionConversionValidator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionConversionValidator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionConversionValidator").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionConversionValidator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionConversionValidator")
        }
    }
}
impl IAVCaptionConversionValidator for AVCaptionConversionValidator {}
pub trait IAVCaptionConversionValidator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithCaptions_timeRange_conversionSettings_(
        &self,
        captions: NSArray,
        timeRange: CMTimeRange,
        conversionSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithCaptions : captions, timeRange : timeRange, conversionSettings : conversionSettings)
    }
    unsafe fn validateCaptionConversionWithWarningHandler_(
        &self,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, validateCaptionConversionWithWarningHandler : handler)
    }
    unsafe fn stopValidating(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopValidating)
    }
    unsafe fn status(&self) -> AVCaptionConversionValidatorStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn captions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, captions)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn warnings(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, warnings)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionValidator").unwrap(), new)
    }
    unsafe fn captionConversionValidatorWithCaptions_timeRange_conversionSettings_(
        captions: NSArray,
        timeRange: CMTimeRange,
        conversionSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionValidator").unwrap(), captionConversionValidatorWithCaptions : captions, timeRange : timeRange, conversionSettings : conversionSettings)
    }
}
pub type AVCaptionConversionWarningType = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionConversionWarning(pub id);
impl std::ops::Deref for AVCaptionConversionWarning {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionConversionWarning {}
impl AVCaptionConversionWarning {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionWarning").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionConversionWarning {}
impl PNSObject for AVCaptionConversionWarning {}
impl std::convert::TryFrom<NSObject> for AVCaptionConversionWarning {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionConversionWarning, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionConversionWarning").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionConversionWarning(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionConversionWarning")
        }
    }
}
impl IAVCaptionConversionWarning for AVCaptionConversionWarning {}
pub trait IAVCaptionConversionWarning: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn warningType(&self) -> AVCaptionConversionWarningType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, warningType)
    }
    unsafe fn rangeOfCaptions(&self) -> NSRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rangeOfCaptions)
    }
    unsafe fn adjustment(&self) -> AVCaptionConversionAdjustment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, adjustment)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionWarning").unwrap(), new)
    }
}
pub type AVCaptionConversionAdjustmentType = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionConversionAdjustment(pub id);
impl std::ops::Deref for AVCaptionConversionAdjustment {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionConversionAdjustment {}
impl AVCaptionConversionAdjustment {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionAdjustment").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionConversionAdjustment {}
impl PNSObject for AVCaptionConversionAdjustment {}
impl std::convert::TryFrom<NSObject> for AVCaptionConversionAdjustment {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionConversionAdjustment, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionConversionAdjustment").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptionConversionAdjustment(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionConversionAdjustment")
        }
    }
}
impl IAVCaptionConversionAdjustment for AVCaptionConversionAdjustment {}
pub trait IAVCaptionConversionAdjustment: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn adjustmentType(&self) -> AVCaptionConversionAdjustmentType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, adjustmentType)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionAdjustment").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionConversionTimeRangeAdjustment(pub id);
impl std::ops::Deref for AVCaptionConversionTimeRangeAdjustment {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionConversionTimeRangeAdjustment {}
impl AVCaptionConversionTimeRangeAdjustment {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionTimeRangeAdjustment").unwrap(), alloc) })
    }
}
impl IAVCaptionConversionAdjustment for AVCaptionConversionTimeRangeAdjustment {}
impl From<AVCaptionConversionTimeRangeAdjustment> for AVCaptionConversionAdjustment {
    fn from(child: AVCaptionConversionTimeRangeAdjustment) -> AVCaptionConversionAdjustment {
        AVCaptionConversionAdjustment(child.0)
    }
}
impl std::convert::TryFrom<AVCaptionConversionAdjustment>
    for AVCaptionConversionTimeRangeAdjustment
{
    type Error = &'static str;
    fn try_from(
        parent: AVCaptionConversionAdjustment,
    ) -> Result<AVCaptionConversionTimeRangeAdjustment, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionConversionTimeRangeAdjustment").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptionConversionTimeRangeAdjustment(parent.0))
        } else {
            Err ("This AVCaptionConversionAdjustment cannot be downcasted to AVCaptionConversionTimeRangeAdjustment" ,)
        }
    }
}
impl INSObject for AVCaptionConversionTimeRangeAdjustment {}
impl PNSObject for AVCaptionConversionTimeRangeAdjustment {}
impl IAVCaptionConversionTimeRangeAdjustment for AVCaptionConversionTimeRangeAdjustment {}
pub trait IAVCaptionConversionTimeRangeAdjustment: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn startTimeOffset(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startTimeOffset)
    }
    unsafe fn durationOffset(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, durationOffset)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionConversionTimeRangeAdjustment").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionFormatConformer(pub id);
impl std::ops::Deref for AVCaptionFormatConformer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionFormatConformer {}
impl AVCaptionFormatConformer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionFormatConformer").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionFormatConformer {}
impl PNSObject for AVCaptionFormatConformer {}
impl std::convert::TryFrom<NSObject> for AVCaptionFormatConformer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionFormatConformer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionFormatConformer").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionFormatConformer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionFormatConformer")
        }
    }
}
impl IAVCaptionFormatConformer for AVCaptionFormatConformer {}
pub trait IAVCaptionFormatConformer: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithConversionSettings_(&self, conversionSettings: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithConversionSettings : conversionSettings)
    }
    unsafe fn conformedCaptionForCaption_error_(
        &self,
        caption: AVCaption,
        outError: *mut NSError,
    ) -> AVCaption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, conformedCaptionForCaption : caption, error : outError)
    }
    unsafe fn conformsCaptionsToTimeRange(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, conformsCaptionsToTimeRange)
    }
    unsafe fn setConformsCaptionsToTimeRange_(&self, conformsCaptionsToTimeRange: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConformsCaptionsToTimeRange : conformsCaptionsToTimeRange)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionFormatConformer").unwrap(), new)
    }
    unsafe fn captionFormatConformerWithConversionSettings_(
        conversionSettings: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionFormatConformer").unwrap(), captionFormatConformerWithConversionSettings : conversionSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVTextStyleRule(pub id);
impl std::ops::Deref for AVTextStyleRule {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVTextStyleRule {}
impl AVTextStyleRule {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), alloc) })
    }
}
impl PNSCopying for AVTextStyleRule {}
impl INSObject for AVTextStyleRule {}
impl PNSObject for AVTextStyleRule {}
impl std::convert::TryFrom<NSObject> for AVTextStyleRule {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVTextStyleRule, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap()) };
        if is_kind_of {
            Ok(AVTextStyleRule(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVTextStyleRule")
        }
    }
}
impl IAVTextStyleRule for AVTextStyleRule {}
pub trait IAVTextStyleRule: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithTextMarkupAttributes_(
        &self,
        textMarkupAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTextMarkupAttributes : textMarkupAttributes)
    }
    unsafe fn initWithTextMarkupAttributes_textSelector_(
        &self,
        textMarkupAttributes: NSDictionary,
        textSelector: NSString,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTextMarkupAttributes : textMarkupAttributes, textSelector : textSelector)
    }
    unsafe fn textMarkupAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textMarkupAttributes)
    }
    unsafe fn textSelector(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textSelector)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), new)
    }
    unsafe fn propertyListForTextStyleRules_(textStyleRules: NSArray) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), propertyListForTextStyleRules : textStyleRules)
    }
    unsafe fn textStyleRulesFromPropertyList_(plist: id) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), textStyleRulesFromPropertyList : plist)
    }
    unsafe fn textStyleRuleWithTextMarkupAttributes_(
        textMarkupAttributes: NSDictionary,
    ) -> AVTextStyleRule
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), textStyleRuleWithTextMarkupAttributes : textMarkupAttributes)
    }
    unsafe fn textStyleRuleWithTextMarkupAttributes_textSelector_(
        textMarkupAttributes: NSDictionary,
        textSelector: NSString,
    ) -> AVTextStyleRule
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVTextStyleRule").unwrap(), textStyleRuleWithTextMarkupAttributes : textMarkupAttributes, textSelector : textSelector)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionRenderer(pub id);
impl std::ops::Deref for AVCaptionRenderer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionRenderer {}
impl AVCaptionRenderer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRenderer").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptionRenderer {}
impl PNSObject for AVCaptionRenderer {}
impl std::convert::TryFrom<NSObject> for AVCaptionRenderer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionRenderer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionRenderer").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionRenderer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionRenderer")
        }
    }
}
impl IAVCaptionRenderer for AVCaptionRenderer {}
pub trait IAVCaptionRenderer: Sized + std::ops::Deref {
    unsafe fn captionSceneChangesInRange_(&self, consideredTimeRange: CMTimeRange) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captionSceneChangesInRange : consideredTimeRange)
    }
    unsafe fn renderInContext_forTime_(&self, ctx: CGContextRef, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, renderInContext : ctx, forTime : time)
    }
    unsafe fn captions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, captions)
    }
    unsafe fn setCaptions_(&self, captions: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCaptions : captions)
    }
    unsafe fn bounds(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bounds)
    }
    unsafe fn setBounds_(&self, bounds: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setBounds : bounds)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptionRendererScene(pub id);
impl std::ops::Deref for AVCaptionRendererScene {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptionRendererScene {}
impl AVCaptionRendererScene {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRendererScene").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCaptionRendererScene {}
impl INSObject for AVCaptionRendererScene {}
impl PNSObject for AVCaptionRendererScene {}
impl std::convert::TryFrom<NSObject> for AVCaptionRendererScene {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptionRendererScene, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptionRendererScene").unwrap()) };
        if is_kind_of {
            Ok(AVCaptionRendererScene(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptionRendererScene")
        }
    }
}
impl IAVCaptionRendererScene for AVCaptionRendererScene {}
pub trait IAVCaptionRendererScene: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn timeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeRange)
    }
    unsafe fn hasActiveCaptions(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasActiveCaptions)
    }
    unsafe fn needsPeriodicRefresh(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, needsPeriodicRefresh)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptionRendererScene").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCompositionTrack(pub id);
impl std::ops::Deref for AVCompositionTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCompositionTrack {}
impl AVCompositionTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCompositionTrack").unwrap(), alloc) })
    }
}
impl IAVAssetTrack for AVCompositionTrack {}
impl PNSCopying for AVCompositionTrack {}
impl PAVAsynchronousKeyValueLoading for AVCompositionTrack {}
impl std::convert::TryFrom<AVAssetTrack> for AVCompositionTrack {
    type Error = &'static str;
    fn try_from(parent: AVAssetTrack) -> Result<AVCompositionTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCompositionTrack").unwrap()) };
        if is_kind_of {
            Ok(AVCompositionTrack(parent.0))
        } else {
            Err("This AVAssetTrack cannot be downcasted to AVCompositionTrack")
        }
    }
}
impl INSObject for AVCompositionTrack {}
impl PNSObject for AVCompositionTrack {}
impl IAVCompositionTrack for AVCompositionTrack {}
pub trait IAVCompositionTrack: Sized + std::ops::Deref {
    unsafe fn segmentForTrackTime_(&self, trackTime: CMTime) -> AVCompositionTrackSegment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, segmentForTrackTime : trackTime)
    }
    unsafe fn segments(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segments)
    }
    unsafe fn formatDescriptionReplacements(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formatDescriptionReplacements)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableCompositionTrack(pub id);
impl std::ops::Deref for AVMutableCompositionTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableCompositionTrack {}
impl AVMutableCompositionTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableCompositionTrack").unwrap(), alloc) })
    }
}
impl IAVCompositionTrack for AVMutableCompositionTrack {}
impl From<AVMutableCompositionTrack> for AVCompositionTrack {
    fn from(child: AVMutableCompositionTrack) -> AVCompositionTrack {
        AVCompositionTrack(child.0)
    }
}
impl std::convert::TryFrom<AVCompositionTrack> for AVMutableCompositionTrack {
    type Error = &'static str;
    fn try_from(parent: AVCompositionTrack) -> Result<AVMutableCompositionTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableCompositionTrack").unwrap()) };
        if is_kind_of {
            Ok(AVMutableCompositionTrack(parent.0))
        } else {
            Err("This AVCompositionTrack cannot be downcasted to AVMutableCompositionTrack")
        }
    }
}
impl IAVAssetTrack for AVMutableCompositionTrack {}
impl PNSCopying for AVMutableCompositionTrack {}
impl PAVAsynchronousKeyValueLoading for AVMutableCompositionTrack {}
impl INSObject for AVMutableCompositionTrack {}
impl PNSObject for AVMutableCompositionTrack {}
impl IAVMutableCompositionTrack for AVMutableCompositionTrack {}
pub trait IAVMutableCompositionTrack: Sized + std::ops::Deref {
    unsafe fn insertTimeRange_ofTrack_atTime_error_(
        &self,
        timeRange: CMTimeRange,
        track: AVAssetTrack,
        startTime: CMTime,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRange : timeRange, ofTrack : track, atTime : startTime, error : outError)
    }
    unsafe fn insertTimeRanges_ofTracks_atTime_error_(
        &self,
        timeRanges: NSArray,
        tracks: NSArray,
        startTime: CMTime,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRanges : timeRanges, ofTracks : tracks, atTime : startTime, error : outError)
    }
    unsafe fn insertEmptyTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertEmptyTimeRange : timeRange)
    }
    unsafe fn removeTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeRange : timeRange)
    }
    unsafe fn scaleTimeRange_toDuration_(&self, timeRange: CMTimeRange, duration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, scaleTimeRange : timeRange, toDuration : duration)
    }
    unsafe fn validateTrackSegments_error_(
        &self,
        trackSegments: NSArray,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, validateTrackSegments : trackSegments, error : outError)
    }
    unsafe fn addTrackAssociationToTrack_type_(
        &self,
        compositionTrack: AVCompositionTrack,
        trackAssociationType: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addTrackAssociationToTrack : compositionTrack, r#type : trackAssociationType)
    }
    unsafe fn removeTrackAssociationToTrack_type_(
        &self,
        compositionTrack: AVCompositionTrack,
        trackAssociationType: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTrackAssociationToTrack : compositionTrack, r#type : trackAssociationType)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn naturalTimeScale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalTimeScale)
    }
    unsafe fn setNaturalTimeScale_(&self, naturalTimeScale: CMTimeScale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setNaturalTimeScale : naturalTimeScale)
    }
    unsafe fn languageCode(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, languageCode)
    }
    unsafe fn setLanguageCode_(&self, languageCode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLanguageCode : languageCode)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn setExtendedLanguageTag_(&self, extendedLanguageTag: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExtendedLanguageTag : extendedLanguageTag)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
    unsafe fn setPreferredTransform_(&self, preferredTransform: CGAffineTransform)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredTransform : preferredTransform)
    }
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn setPreferredVolume_(&self, preferredVolume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVolume : preferredVolume)
    }
    unsafe fn segments(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segments)
    }
    unsafe fn setSegments_(&self, segments: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSegments : segments)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCompositionTrackFormatDescriptionReplacement(pub id);
impl std::ops::Deref for AVCompositionTrackFormatDescriptionReplacement {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCompositionTrackFormatDescriptionReplacement {}
impl AVCompositionTrackFormatDescriptionReplacement {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVCompositionTrackFormatDescriptionReplacement").unwrap(), alloc)
        })
    }
}
impl PNSSecureCoding for AVCompositionTrackFormatDescriptionReplacement {}
impl INSObject for AVCompositionTrackFormatDescriptionReplacement {}
impl PNSObject for AVCompositionTrackFormatDescriptionReplacement {}
impl std::convert::TryFrom<NSObject> for AVCompositionTrackFormatDescriptionReplacement {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVCompositionTrackFormatDescriptionReplacement, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCompositionTrackFormatDescriptionReplacement").unwrap())
        };
        if is_kind_of {
            Ok(AVCompositionTrackFormatDescriptionReplacement(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVCompositionTrackFormatDescriptionReplacement" ,)
        }
    }
}
impl IAVCompositionTrackFormatDescriptionReplacement
    for AVCompositionTrackFormatDescriptionReplacement
{
}
pub trait IAVCompositionTrackFormatDescriptionReplacement: Sized + std::ops::Deref {
    unsafe fn originalFormatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, originalFormatDescription)
    }
    unsafe fn replacementFormatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, replacementFormatDescription)
    }
}
impl AVMutableCompositionTrack_AVMutableCompositionTrackFormatDescriptionReplacement
    for AVMutableCompositionTrack
{
}
pub trait AVMutableCompositionTrack_AVMutableCompositionTrackFormatDescriptionReplacement:
    Sized + std::ops::Deref
{
    unsafe fn replaceFormatDescription_withFormatDescription_(
        &self,
        originalFormatDescription: CMFormatDescriptionRef,
        replacementFormatDescription: CMFormatDescriptionRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replaceFormatDescription : originalFormatDescription, withFormatDescription : replacementFormatDescription)
    }
}
impl AVCompositionTrack_SynchronousTrackInterface for AVCompositionTrack {}
pub trait AVCompositionTrack_SynchronousTrackInterface: Sized + std::ops::Deref {
    unsafe fn hasMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn samplePresentationTimeForTrackTime_(&self, trackTime: CMTime) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, samplePresentationTimeForTrackTime : trackTime)
    }
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn associatedTracksOfType_(&self, trackAssociationType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, associatedTracksOfType : trackAssociationType)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVComposition(pub id);
impl std::ops::Deref for AVComposition {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVComposition {}
impl AVComposition {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVComposition").unwrap(), alloc) })
    }
}
impl PNSMutableCopying for AVComposition {}
impl IAVAsset for AVComposition {}
impl PNSCopying for AVComposition {}
impl PAVAsynchronousKeyValueLoading for AVComposition {}
impl std::convert::TryFrom<AVAsset> for AVComposition {
    type Error = &'static str;
    fn try_from(parent: AVAsset) -> Result<AVComposition, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVComposition").unwrap()) };
        if is_kind_of {
            Ok(AVComposition(parent.0))
        } else {
            Err("This AVAsset cannot be downcasted to AVComposition")
        }
    }
}
impl INSObject for AVComposition {}
impl PNSObject for AVComposition {}
impl IAVComposition for AVComposition {}
pub trait IAVComposition: Sized + std::ops::Deref {
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn URLAssetInitializationOptions(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URLAssetInitializationOptions)
    }
}
impl AVComposition_AVCompositionTrackInspection for AVComposition {}
pub trait AVComposition_AVCompositionTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVCompositionTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableComposition(pub id);
impl std::ops::Deref for AVMutableComposition {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableComposition {}
impl AVMutableComposition {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableComposition").unwrap(), alloc) })
    }
}
impl IAVComposition for AVMutableComposition {}
impl PNSMutableCopying for AVMutableComposition {}
impl From<AVMutableComposition> for AVComposition {
    fn from(child: AVMutableComposition) -> AVComposition {
        AVComposition(child.0)
    }
}
impl std::convert::TryFrom<AVComposition> for AVMutableComposition {
    type Error = &'static str;
    fn try_from(parent: AVComposition) -> Result<AVMutableComposition, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableComposition").unwrap()) };
        if is_kind_of {
            Ok(AVMutableComposition(parent.0))
        } else {
            Err("This AVComposition cannot be downcasted to AVMutableComposition")
        }
    }
}
impl IAVAsset for AVMutableComposition {}
impl PNSCopying for AVMutableComposition {}
impl PAVAsynchronousKeyValueLoading for AVMutableComposition {}
impl INSObject for AVMutableComposition {}
impl PNSObject for AVMutableComposition {}
impl IAVMutableComposition for AVMutableComposition {}
pub trait IAVMutableComposition: Sized + std::ops::Deref {
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn setNaturalSize_(&self, naturalSize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setNaturalSize : naturalSize)
    }
    unsafe fn composition() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableComposition").unwrap(), composition)
    }
    unsafe fn compositionWithURLAssetInitializationOptions_(
        URLAssetInitializationOptions: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableComposition").unwrap(), compositionWithURLAssetInitializationOptions : URLAssetInitializationOptions)
    }
}
impl AVMutableComposition_AVMutableCompositionCompositionLevelEditing for AVMutableComposition {}
pub trait AVMutableComposition_AVMutableCompositionCompositionLevelEditing:
    Sized + std::ops::Deref
{
    unsafe fn insertTimeRange_ofAsset_atTime_error_(
        &self,
        timeRange: CMTimeRange,
        asset: AVAsset,
        startTime: CMTime,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRange : timeRange, ofAsset : asset, atTime : startTime, error : outError)
    }
    unsafe fn insertTimeRange_ofAsset_atTime_completionHandler_(
        &self,
        timeRange: CMTimeRange,
        asset: AVAsset,
        startTime: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRange : timeRange, ofAsset : asset, atTime : startTime, completionHandler : completionHandler)
    }
    unsafe fn insertEmptyTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertEmptyTimeRange : timeRange)
    }
    unsafe fn removeTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeRange : timeRange)
    }
    unsafe fn scaleTimeRange_toDuration_(&self, timeRange: CMTimeRange, duration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, scaleTimeRange : timeRange, toDuration : duration)
    }
}
impl AVMutableComposition_AVMutableCompositionTrackLevelEditing for AVMutableComposition {}
pub trait AVMutableComposition_AVMutableCompositionTrackLevelEditing:
    Sized + std::ops::Deref
{
    unsafe fn addMutableTrackWithMediaType_preferredTrackID_(
        &self,
        mediaType: NSString,
        preferredTrackID: CMPersistentTrackID,
    ) -> AVMutableCompositionTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addMutableTrackWithMediaType : mediaType, preferredTrackID : preferredTrackID)
    }
    unsafe fn removeTrack_(&self, track: AVCompositionTrack)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTrack : track)
    }
    unsafe fn mutableTrackCompatibleWithTrack_(
        &self,
        track: AVAssetTrack,
    ) -> AVMutableCompositionTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mutableTrackCompatibleWithTrack : track)
    }
}
impl AVMutableComposition_AVMutableCompositionTrackInspection for AVMutableComposition {}
pub trait AVMutableComposition_AVMutableCompositionTrackInspection:
    Sized + std::ops::Deref
{
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVMutableCompositionTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
impl AVComposition_SynchronousAssetInterface for AVComposition {}
pub trait AVComposition_SynchronousAssetInterface: Sized + std::ops::Deref {
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn chapterMetadataGroupsWithTitleLocale_containingItemsWithCommonKeys_(
        &self,
        locale: NSLocale,
        commonKeys: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsWithTitleLocale : locale, containingItemsWithCommonKeys : commonKeys)
    }
    unsafe fn chapterMetadataGroupsBestMatchingPreferredLanguages_(
        &self,
        preferredLanguages: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsBestMatchingPreferredLanguages : preferredLanguages)
    }
    unsafe fn mediaSelectionGroupForMediaCharacteristic_(
        &self,
        mediaCharacteristic: NSString,
    ) -> AVMediaSelectionGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionGroupForMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn unusedTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unusedTrackID)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCompositionTrackSegment(pub id);
impl std::ops::Deref for AVCompositionTrackSegment {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCompositionTrackSegment {}
impl AVCompositionTrackSegment {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCompositionTrackSegment").unwrap(), alloc) })
    }
}
impl IAVAssetTrackSegment for AVCompositionTrackSegment {}
impl From<AVCompositionTrackSegment> for AVAssetTrackSegment {
    fn from(child: AVCompositionTrackSegment) -> AVAssetTrackSegment {
        AVAssetTrackSegment(child.0)
    }
}
impl std::convert::TryFrom<AVAssetTrackSegment> for AVCompositionTrackSegment {
    type Error = &'static str;
    fn try_from(parent: AVAssetTrackSegment) -> Result<AVCompositionTrackSegment, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCompositionTrackSegment").unwrap()) };
        if is_kind_of {
            Ok(AVCompositionTrackSegment(parent.0))
        } else {
            Err("This AVAssetTrackSegment cannot be downcasted to AVCompositionTrackSegment")
        }
    }
}
impl INSObject for AVCompositionTrackSegment {}
impl PNSObject for AVCompositionTrackSegment {}
impl IAVCompositionTrackSegment for AVCompositionTrackSegment {}
pub trait IAVCompositionTrackSegment: Sized + std::ops::Deref {
    unsafe fn initWithURL_trackID_sourceTimeRange_targetTimeRange_(
        &self,
        URL: NSURL,
        trackID: CMPersistentTrackID,
        sourceTimeRange: CMTimeRange,
        targetTimeRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL, trackID : trackID, sourceTimeRange : sourceTimeRange, targetTimeRange : targetTimeRange)
    }
    unsafe fn initWithTimeRange_(&self, timeRange: CMTimeRange) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTimeRange : timeRange)
    }
    unsafe fn isEmpty(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEmpty)
    }
    unsafe fn sourceURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceURL)
    }
    unsafe fn sourceTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceTrackID)
    }
    unsafe fn compositionTrackSegmentWithURL_trackID_sourceTimeRange_targetTimeRange_(
        URL: NSURL,
        trackID: CMPersistentTrackID,
        sourceTimeRange: CMTimeRange,
        targetTimeRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCompositionTrackSegment").unwrap(), compositionTrackSegmentWithURL : URL, trackID : trackID, sourceTimeRange : sourceTimeRange, targetTimeRange : targetTimeRange)
    }
    unsafe fn compositionTrackSegmentWithTimeRange_(timeRange: CMTimeRange) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCompositionTrackSegment").unwrap(), compositionTrackSegmentWithTimeRange : timeRange)
    }
}
pub type AVError = NSInteger;
pub trait NSValue_NSValueCMVideoDimensionsExtensions: Sized + std::ops::Deref {
    unsafe fn CMVideoDimensionsValue(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, CMVideoDimensionsValue)
    }
    unsafe fn valueWithCMVideoDimensions_(dimensions: CMVideoDimensions) -> NSValue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"NSValue").unwrap(), valueWithCMVideoDimensions : dimensions)
    }
}
pub type AVMetadataIdentifier = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataItem(pub id);
impl std::ops::Deref for AVMetadataItem {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataItem {}
impl AVMetadataItem {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), alloc) })
    }
}
impl PAVAsynchronousKeyValueLoading for AVMetadataItem {}
impl PNSCopying for AVMetadataItem {}
impl PNSMutableCopying for AVMetadataItem {}
impl INSObject for AVMetadataItem {}
impl PNSObject for AVMetadataItem {}
impl std::convert::TryFrom<NSObject> for AVMetadataItem {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetadataItem, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataItem(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetadataItem")
        }
    }
}
impl IAVMetadataItem for AVMetadataItem {}
pub trait IAVMetadataItem: Sized + std::ops::Deref {
    unsafe fn identifier(&self) -> AVMetadataIdentifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn locale(&self) -> NSLocale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, locale)
    }
    unsafe fn time(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, time)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn dataType(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataType)
    }
    unsafe fn value(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, value)
    }
    unsafe fn extraAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extraAttributes)
    }
}
impl AVMetadataItem_AVMetadataItemDateRepresentation for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemDateRepresentation: Sized + std::ops::Deref {
    unsafe fn startDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startDate)
    }
}
impl AVMetadataItem_AVMetadataItemTypeCoercion for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemTypeCoercion: Sized + std::ops::Deref {
    unsafe fn stringValue(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stringValue)
    }
    unsafe fn numberValue(&self) -> NSNumber
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberValue)
    }
    unsafe fn dateValue(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dateValue)
    }
    unsafe fn dataValue(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataValue)
    }
}
impl AVMetadataItem_AVAsynchronousKeyValueLoading for AVMetadataItem {}
pub trait AVMetadataItem_AVAsynchronousKeyValueLoading: Sized + std::ops::Deref {
    unsafe fn statusOfValueForKey_error_(
        &self,
        key: NSString,
        outError: *mut NSError,
    ) -> AVKeyValueStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, statusOfValueForKey : key, error : outError)
    }
    unsafe fn loadValuesAsynchronouslyForKeys_completionHandler_(
        &self,
        keys: NSArray,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadValuesAsynchronouslyForKeys : keys, completionHandler : handler)
    }
}
impl AVMetadataItem_AVMetadataItemArrayFiltering for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemArrayFiltering: Sized + std::ops::Deref {
    unsafe fn metadataItemsFromArray_filteredAndSortedAccordingToPreferredLanguages_(
        metadataItems: NSArray,
        preferredLanguages: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemsFromArray : metadataItems, filteredAndSortedAccordingToPreferredLanguages : preferredLanguages)
    }
    unsafe fn metadataItemsFromArray_filteredByIdentifier_(
        metadataItems: NSArray,
        identifier: NSString,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemsFromArray : metadataItems, filteredByIdentifier : identifier)
    }
    unsafe fn metadataItemsFromArray_filteredByMetadataItemFilter_(
        metadataItems: NSArray,
        metadataItemFilter: AVMetadataItemFilter,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemsFromArray : metadataItems, filteredByMetadataItemFilter : metadataItemFilter)
    }
}
impl AVMetadataItem_AVMetadataItemKeyAndKeyspace for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemKeyAndKeyspace: Sized + std::ops::Deref {
    unsafe fn key(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, key)
    }
    unsafe fn commonKey(&self) -> AVMetadataKey
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, commonKey)
    }
    unsafe fn keySpace(&self) -> AVMetadataKeySpace
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, keySpace)
    }
    unsafe fn identifierForKey_keySpace_(key: id, keySpace: NSString) -> AVMetadataIdentifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), identifierForKey : key, keySpace : keySpace)
    }
    unsafe fn keySpaceForIdentifier_(identifier: NSString) -> AVMetadataKeySpace
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), keySpaceForIdentifier : identifier)
    }
    unsafe fn keyForIdentifier_(identifier: NSString) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), keyForIdentifier : identifier)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableMetadataItem(pub id);
impl std::ops::Deref for AVMutableMetadataItem {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableMetadataItem {}
impl AVMutableMetadataItem {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMetadataItem").unwrap(), alloc) })
    }
}
impl IAVMetadataItem for AVMutableMetadataItem {}
impl PAVAsynchronousKeyValueLoading for AVMutableMetadataItem {}
impl PNSCopying for AVMutableMetadataItem {}
impl PNSMutableCopying for AVMutableMetadataItem {}
impl From<AVMutableMetadataItem> for AVMetadataItem {
    fn from(child: AVMutableMetadataItem) -> AVMetadataItem {
        AVMetadataItem(child.0)
    }
}
impl std::convert::TryFrom<AVMetadataItem> for AVMutableMetadataItem {
    type Error = &'static str;
    fn try_from(parent: AVMetadataItem) -> Result<AVMutableMetadataItem, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableMetadataItem").unwrap()) };
        if is_kind_of {
            Ok(AVMutableMetadataItem(parent.0))
        } else {
            Err("This AVMetadataItem cannot be downcasted to AVMutableMetadataItem")
        }
    }
}
impl INSObject for AVMutableMetadataItem {}
impl PNSObject for AVMutableMetadataItem {}
impl IAVMutableMetadataItem for AVMutableMetadataItem {}
pub trait IAVMutableMetadataItem: Sized + std::ops::Deref {
    unsafe fn identifier(&self) -> AVMetadataIdentifier
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn setIdentifier_(&self, identifier: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setIdentifier : identifier)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn setExtendedLanguageTag_(&self, extendedLanguageTag: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExtendedLanguageTag : extendedLanguageTag)
    }
    unsafe fn locale(&self) -> NSLocale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, locale)
    }
    unsafe fn setLocale_(&self, locale: NSLocale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLocale : locale)
    }
    unsafe fn time(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, time)
    }
    unsafe fn setTime_(&self, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTime : time)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn setDuration_(&self, duration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDuration : duration)
    }
    unsafe fn dataType(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataType)
    }
    unsafe fn setDataType_(&self, dataType: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDataType : dataType)
    }
    unsafe fn value(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, value)
    }
    unsafe fn setValue_(&self, value: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setValue : value)
    }
    unsafe fn extraAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extraAttributes)
    }
    unsafe fn setExtraAttributes_(&self, extraAttributes: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExtraAttributes : extraAttributes)
    }
    unsafe fn metadataItem() -> AVMutableMetadataItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMetadataItem").unwrap(), metadataItem)
    }
}
impl AVMutableMetadataItem_AVMutableMetadataItemDateRepresentation for AVMutableMetadataItem {}
pub trait AVMutableMetadataItem_AVMutableMetadataItemDateRepresentation:
    Sized + std::ops::Deref
{
    unsafe fn startDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startDate)
    }
    unsafe fn setStartDate_(&self, startDate: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setStartDate : startDate)
    }
}
impl AVMutableMetadataItem_AVMutableMetadataItemKeyAndKeyspace for AVMutableMetadataItem {}
pub trait AVMutableMetadataItem_AVMutableMetadataItemKeyAndKeyspace:
    Sized + std::ops::Deref
{
    unsafe fn keySpace(&self) -> AVMetadataKeySpace
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, keySpace)
    }
    unsafe fn setKeySpace_(&self, keySpace: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setKeySpace : keySpace)
    }
    unsafe fn key(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, key)
    }
    unsafe fn setKey_(&self, key: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setKey : key)
    }
}
impl AVMetadataItem_AVMetadataItemLazyValueLoading for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemLazyValueLoading: Sized + std::ops::Deref {
    unsafe fn metadataItemWithPropertiesOfMetadataItem_valueLoadingHandler_(
        metadataItem: AVMetadataItem,
        handler: *mut ::std::os::raw::c_void,
    ) -> AVMetadataItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemWithPropertiesOfMetadataItem : metadataItem, valueLoadingHandler : handler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataItemValueRequest(pub id);
impl std::ops::Deref for AVMetadataItemValueRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataItemValueRequest {}
impl AVMetadataItemValueRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItemValueRequest").unwrap(), alloc) })
    }
}
impl INSObject for AVMetadataItemValueRequest {}
impl PNSObject for AVMetadataItemValueRequest {}
impl std::convert::TryFrom<NSObject> for AVMetadataItemValueRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetadataItemValueRequest, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataItemValueRequest").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataItemValueRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetadataItemValueRequest")
        }
    }
}
impl IAVMetadataItemValueRequest for AVMetadataItemValueRequest {}
pub trait IAVMetadataItemValueRequest: Sized + std::ops::Deref {
    unsafe fn respondWithValue_(&self, value: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, respondWithValue : value)
    }
    unsafe fn respondWithError_(&self, error: NSError)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, respondWithError : error)
    }
    unsafe fn metadataItem(&self) -> AVMetadataItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataItem)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataItemFilter(pub id);
impl std::ops::Deref for AVMetadataItemFilter {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataItemFilter {}
impl AVMetadataItemFilter {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItemFilter").unwrap(), alloc) })
    }
}
impl INSObject for AVMetadataItemFilter {}
impl PNSObject for AVMetadataItemFilter {}
impl std::convert::TryFrom<NSObject> for AVMetadataItemFilter {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetadataItemFilter, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataItemFilter").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataItemFilter(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetadataItemFilter")
        }
    }
}
impl IAVMetadataItemFilter for AVMetadataItemFilter {}
pub trait IAVMetadataItemFilter: Sized + std::ops::Deref {
    unsafe fn metadataItemFilterForSharing() -> AVMetadataItemFilter
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItemFilter").unwrap(), metadataItemFilterForSharing)
    }
}
impl AVMetadataItem_AVMetadataItemArrayFilteringDeprecable for AVMetadataItem {}
pub trait AVMetadataItem_AVMetadataItemArrayFilteringDeprecable: Sized + std::ops::Deref {
    unsafe fn metadataItemsFromArray_withLocale_(
        metadataItems: NSArray,
        locale: NSLocale,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemsFromArray : metadataItems, withLocale : locale)
    }
    unsafe fn metadataItemsFromArray_withKey_keySpace_(
        metadataItems: NSArray,
        key: id,
        keySpace: NSString,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataItem").unwrap(), metadataItemsFromArray : metadataItems, withKey : key, keySpace : keySpace)
    }
}
impl AVMutableMetadataItem_SynchronousMetadataItemInterface for AVMutableMetadataItem {}
pub trait AVMutableMetadataItem_SynchronousMetadataItemInterface: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMovieTrack(pub id);
impl std::ops::Deref for AVMovieTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMovieTrack {}
impl AVMovieTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMovieTrack").unwrap(), alloc) })
    }
}
impl IAVAssetTrack for AVMovieTrack {}
impl PNSCopying for AVMovieTrack {}
impl PAVAsynchronousKeyValueLoading for AVMovieTrack {}
impl std::convert::TryFrom<AVAssetTrack> for AVMovieTrack {
    type Error = &'static str;
    fn try_from(parent: AVAssetTrack) -> Result<AVMovieTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMovieTrack").unwrap()) };
        if is_kind_of {
            Ok(AVMovieTrack(parent.0))
        } else {
            Err("This AVAssetTrack cannot be downcasted to AVMovieTrack")
        }
    }
}
impl INSObject for AVMovieTrack {}
impl PNSObject for AVMovieTrack {}
impl IAVMovieTrack for AVMovieTrack {}
pub trait IAVMovieTrack: Sized + std::ops::Deref {
    unsafe fn mediaPresentationTimeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaPresentationTimeRange)
    }
    unsafe fn mediaDecodeTimeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaDecodeTimeRange)
    }
    unsafe fn alternateGroupID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alternateGroupID)
    }
}
impl AVMovieTrack_AVMovieTrackMediaDataStorage for AVMovieTrack {}
pub trait AVMovieTrack_AVMovieTrackMediaDataStorage: Sized + std::ops::Deref {
    unsafe fn mediaDataStorage(&self) -> AVMediaDataStorage
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaDataStorage)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableMovieTrack(pub id);
impl std::ops::Deref for AVMutableMovieTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableMovieTrack {}
impl AVMutableMovieTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMovieTrack").unwrap(), alloc) })
    }
}
impl IAVMovieTrack for AVMutableMovieTrack {}
impl From<AVMutableMovieTrack> for AVMovieTrack {
    fn from(child: AVMutableMovieTrack) -> AVMovieTrack {
        AVMovieTrack(child.0)
    }
}
impl std::convert::TryFrom<AVMovieTrack> for AVMutableMovieTrack {
    type Error = &'static str;
    fn try_from(parent: AVMovieTrack) -> Result<AVMutableMovieTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableMovieTrack").unwrap()) };
        if is_kind_of {
            Ok(AVMutableMovieTrack(parent.0))
        } else {
            Err("This AVMovieTrack cannot be downcasted to AVMutableMovieTrack")
        }
    }
}
impl IAVAssetTrack for AVMutableMovieTrack {}
impl PNSCopying for AVMutableMovieTrack {}
impl PAVAsynchronousKeyValueLoading for AVMutableMovieTrack {}
impl INSObject for AVMutableMovieTrack {}
impl PNSObject for AVMutableMovieTrack {}
impl IAVMutableMovieTrack for AVMutableMovieTrack {}
pub trait IAVMutableMovieTrack: Sized + std::ops::Deref {
    unsafe fn mediaDataStorage(&self) -> AVMediaDataStorage
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaDataStorage)
    }
    unsafe fn setMediaDataStorage_(&self, mediaDataStorage: AVMediaDataStorage)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMediaDataStorage : mediaDataStorage)
    }
    unsafe fn sampleReferenceBaseURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleReferenceBaseURL)
    }
    unsafe fn setSampleReferenceBaseURL_(&self, sampleReferenceBaseURL: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSampleReferenceBaseURL : sampleReferenceBaseURL)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn alternateGroupID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alternateGroupID)
    }
    unsafe fn setAlternateGroupID_(&self, alternateGroupID: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlternateGroupID : alternateGroupID)
    }
    unsafe fn isModified(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isModified)
    }
    unsafe fn setModified_(&self, modified: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setModified : modified)
    }
    unsafe fn hasProtectedContent(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasProtectedContent)
    }
    unsafe fn timescale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timescale)
    }
    unsafe fn setTimescale_(&self, timescale: CMTimeScale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimescale : timescale)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackLanguageProperties for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackLanguageProperties:
    Sized + std::ops::Deref
{
    unsafe fn languageCode(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, languageCode)
    }
    unsafe fn setLanguageCode_(&self, languageCode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLanguageCode : languageCode)
    }
    unsafe fn extendedLanguageTag(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLanguageTag)
    }
    unsafe fn setExtendedLanguageTag_(&self, extendedLanguageTag: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExtendedLanguageTag : extendedLanguageTag)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackVisualProperties for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackVisualProperties: Sized + std::ops::Deref {
    unsafe fn naturalSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, naturalSize)
    }
    unsafe fn setNaturalSize_(&self, naturalSize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setNaturalSize : naturalSize)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
    unsafe fn setPreferredTransform_(&self, preferredTransform: CGAffineTransform)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredTransform : preferredTransform)
    }
    unsafe fn layer(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, layer)
    }
    unsafe fn setLayer_(&self, layer: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLayer : layer)
    }
    unsafe fn cleanApertureDimensions(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cleanApertureDimensions)
    }
    unsafe fn setCleanApertureDimensions_(&self, cleanApertureDimensions: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCleanApertureDimensions : cleanApertureDimensions)
    }
    unsafe fn productionApertureDimensions(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, productionApertureDimensions)
    }
    unsafe fn setProductionApertureDimensions_(&self, productionApertureDimensions: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setProductionApertureDimensions : productionApertureDimensions)
    }
    unsafe fn encodedPixelsDimensions(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, encodedPixelsDimensions)
    }
    unsafe fn setEncodedPixelsDimensions_(&self, encodedPixelsDimensions: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEncodedPixelsDimensions : encodedPixelsDimensions)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackAudibleProperties for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackAudibleProperties:
    Sized + std::ops::Deref
{
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn setPreferredVolume_(&self, preferredVolume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVolume : preferredVolume)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackChunkProperties for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackChunkProperties: Sized + std::ops::Deref {
    unsafe fn preferredMediaChunkSize(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaChunkSize)
    }
    unsafe fn setPreferredMediaChunkSize_(&self, preferredMediaChunkSize: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMediaChunkSize : preferredMediaChunkSize)
    }
    unsafe fn preferredMediaChunkDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaChunkDuration)
    }
    unsafe fn setPreferredMediaChunkDuration_(&self, preferredMediaChunkDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMediaChunkDuration : preferredMediaChunkDuration)
    }
    unsafe fn preferredMediaChunkAlignment(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMediaChunkAlignment)
    }
    unsafe fn setPreferredMediaChunkAlignment_(&self, preferredMediaChunkAlignment: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMediaChunkAlignment : preferredMediaChunkAlignment)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackTrackLevelEditing for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackTrackLevelEditing:
    Sized + std::ops::Deref
{
    unsafe fn insertTimeRange_ofTrack_atTime_copySampleData_error_(
        &self,
        timeRange: CMTimeRange,
        track: AVAssetTrack,
        startTime: CMTime,
        copySampleData: BOOL,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRange : timeRange, ofTrack : track, atTime : startTime, copySampleData : copySampleData, error : outError)
    }
    unsafe fn insertEmptyTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertEmptyTimeRange : timeRange)
    }
    unsafe fn removeTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeRange : timeRange)
    }
    unsafe fn scaleTimeRange_toDuration_(&self, timeRange: CMTimeRange, duration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, scaleTimeRange : timeRange, toDuration : duration)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackMetadataEditing for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackMetadataEditing: Sized + std::ops::Deref {
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackTrackAssociations for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackTrackAssociations:
    Sized + std::ops::Deref
{
    unsafe fn addTrackAssociationToTrack_type_(
        &self,
        movieTrack: AVMovieTrack,
        trackAssociationType: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addTrackAssociationToTrack : movieTrack, r#type : trackAssociationType)
    }
    unsafe fn removeTrackAssociationToTrack_type_(
        &self,
        movieTrack: AVMovieTrack,
        trackAssociationType: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTrackAssociationToTrack : movieTrack, r#type : trackAssociationType)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackFormatDescriptions for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackFormatDescriptions:
    Sized + std::ops::Deref
{
    unsafe fn replaceFormatDescription_withFormatDescription_(
        &self,
        formatDescription: CMFormatDescriptionRef,
        newFormatDescription: CMFormatDescriptionRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replaceFormatDescription : formatDescription, withFormatDescription : newFormatDescription)
    }
}
impl AVMutableMovieTrack_AVMutableMovieTrackSampleLevelEditing for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_AVMutableMovieTrackSampleLevelEditing:
    Sized + std::ops::Deref
{
    unsafe fn appendSampleBuffer_decodeTime_presentationTime_error_(
        &self,
        sampleBuffer: CMSampleBufferRef,
        outDecodeTime: *mut CMTime,
        outPresentationTime: *mut CMTime,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendSampleBuffer : sampleBuffer, decodeTime : outDecodeTime, presentationTime : outPresentationTime, error : outError)
    }
    unsafe fn insertMediaTimeRange_intoTimeRange_(
        &self,
        mediaTimeRange: CMTimeRange,
        trackTimeRange: CMTimeRange,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertMediaTimeRange : mediaTimeRange, intoTimeRange : trackTimeRange)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedMovieTrack(pub id);
impl std::ops::Deref for AVFragmentedMovieTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedMovieTrack {}
impl AVFragmentedMovieTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedMovieTrack").unwrap(), alloc) })
    }
}
impl IAVMovieTrack for AVFragmentedMovieTrack {}
impl std::convert::TryFrom<AVMovieTrack> for AVFragmentedMovieTrack {
    type Error = &'static str;
    fn try_from(parent: AVMovieTrack) -> Result<AVFragmentedMovieTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedMovieTrack").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedMovieTrack(parent.0))
        } else {
            Err("This AVMovieTrack cannot be downcasted to AVFragmentedMovieTrack")
        }
    }
}
impl IAVAssetTrack for AVFragmentedMovieTrack {}
impl PNSCopying for AVFragmentedMovieTrack {}
impl PAVAsynchronousKeyValueLoading for AVFragmentedMovieTrack {}
impl INSObject for AVFragmentedMovieTrack {}
impl PNSObject for AVFragmentedMovieTrack {}
impl IAVFragmentedMovieTrack for AVFragmentedMovieTrack {}
pub trait IAVFragmentedMovieTrack: Sized + std::ops::Deref {}
impl AVMutableMovieTrack_SynchronousTrackInterface for AVMutableMovieTrack {}
pub trait AVMutableMovieTrack_SynchronousTrackInterface: Sized + std::ops::Deref {
    unsafe fn hasMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn segmentForTrackTime_(&self, trackTime: CMTime) -> AVAssetTrackSegment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, segmentForTrackTime : trackTime)
    }
    unsafe fn samplePresentationTimeForTrackTime_(&self, trackTime: CMTime) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, samplePresentationTimeForTrackTime : trackTime)
    }
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn associatedTracksOfType_(&self, trackAssociationType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, associatedTracksOfType : trackAssociationType)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMovie(pub id);
impl std::ops::Deref for AVMovie {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMovie {}
impl AVMovie {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMovie").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMovie {}
impl PNSMutableCopying for AVMovie {}
impl IAVAsset for AVMovie {}
impl PAVAsynchronousKeyValueLoading for AVMovie {}
impl std::convert::TryFrom<AVAsset> for AVMovie {
    type Error = &'static str;
    fn try_from(parent: AVAsset) -> Result<AVMovie, Self::Error> {
        let is_kind_of: bool = unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMovie").unwrap()) };
        if is_kind_of {
            Ok(AVMovie(parent.0))
        } else {
            Err("This AVAsset cannot be downcasted to AVMovie")
        }
    }
}
impl INSObject for AVMovie {}
impl PNSObject for AVMovie {}
impl IAVMovie for AVMovie {}
pub trait IAVMovie: Sized + std::ops::Deref {
    unsafe fn initWithURL_options_(&self, URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL, options : options)
    }
    unsafe fn initWithData_options_(&self, data: NSData, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithData : data, options : options)
    }
    unsafe fn URL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URL)
    }
    unsafe fn data(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, data)
    }
    unsafe fn defaultMediaDataStorage(&self) -> AVMediaDataStorage
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultMediaDataStorage)
    }
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn canContainMovieFragments(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canContainMovieFragments)
    }
    unsafe fn containsMovieFragments(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, containsMovieFragments)
    }
    unsafe fn movieTypes() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMovie").unwrap(), movieTypes)
    }
    unsafe fn movieWithURL_options_(URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMovie").unwrap(), movieWithURL : URL, options : options)
    }
    unsafe fn movieWithData_options_(data: NSData, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMovie").unwrap(), movieWithData : data, options : options)
    }
}
pub type AVMovieWritingOptions = NSUInteger;
impl AVMovie_AVMovieMovieHeaderSupport for AVMovie {}
pub trait AVMovie_AVMovieMovieHeaderSupport: Sized + std::ops::Deref {
    unsafe fn movieHeaderWithFileType_error_(
        &self,
        fileType: NSString,
        outError: *mut NSError,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, movieHeaderWithFileType : fileType, error : outError)
    }
    unsafe fn writeMovieHeaderToURL_fileType_options_error_(
        &self,
        URL: NSURL,
        fileType: NSString,
        options: AVMovieWritingOptions,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, writeMovieHeaderToURL : URL, fileType : fileType, options : options, error : outError)
    }
    unsafe fn isCompatibleWithFileType_(&self, fileType: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isCompatibleWithFileType : fileType)
    }
}
impl AVMovie_AVMovieTrackInspection for AVMovie {}
pub trait AVMovie_AVMovieTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVMovieTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMutableMovie(pub id);
impl std::ops::Deref for AVMutableMovie {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMutableMovie {}
impl AVMutableMovie {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMovie").unwrap(), alloc) })
    }
}
impl IAVMovie for AVMutableMovie {}
impl PNSCopying for AVMutableMovie {}
impl PNSMutableCopying for AVMutableMovie {}
impl From<AVMutableMovie> for AVMovie {
    fn from(child: AVMutableMovie) -> AVMovie {
        AVMovie(child.0)
    }
}
impl std::convert::TryFrom<AVMovie> for AVMutableMovie {
    type Error = &'static str;
    fn try_from(parent: AVMovie) -> Result<AVMutableMovie, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMutableMovie").unwrap()) };
        if is_kind_of {
            Ok(AVMutableMovie(parent.0))
        } else {
            Err("This AVMovie cannot be downcasted to AVMutableMovie")
        }
    }
}
impl IAVAsset for AVMutableMovie {}
impl PAVAsynchronousKeyValueLoading for AVMutableMovie {}
impl INSObject for AVMutableMovie {}
impl PNSObject for AVMutableMovie {}
impl IAVMutableMovie for AVMutableMovie {}
pub trait IAVMutableMovie: Sized + std::ops::Deref {
    unsafe fn initWithURL_options_error_(
        &self,
        URL: NSURL,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL, options : options, error : outError)
    }
    unsafe fn initWithData_options_error_(
        &self,
        data: NSData,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithData : data, options : options, error : outError)
    }
    unsafe fn initWithSettingsFromMovie_options_error_(
        &self,
        movie: AVMovie,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithSettingsFromMovie : movie, options : options, error : outError)
    }
    unsafe fn preferredRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredRate)
    }
    unsafe fn setPreferredRate_(&self, preferredRate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredRate : preferredRate)
    }
    unsafe fn preferredVolume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVolume)
    }
    unsafe fn setPreferredVolume_(&self, preferredVolume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVolume : preferredVolume)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
    unsafe fn setPreferredTransform_(&self, preferredTransform: CGAffineTransform)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredTransform : preferredTransform)
    }
    unsafe fn timescale(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timescale)
    }
    unsafe fn setTimescale_(&self, timescale: CMTimeScale)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimescale : timescale)
    }
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn movieWithURL_options_error_(
        URL: NSURL,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMovie").unwrap(), movieWithURL : URL, options : options, error : outError)
    }
    unsafe fn movieWithData_options_error_(
        data: NSData,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMovie").unwrap(), movieWithData : data, options : options, error : outError)
    }
    unsafe fn movieWithSettingsFromMovie_options_error_(
        movie: AVMovie,
        options: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMutableMovie").unwrap(), movieWithSettingsFromMovie : movie, options : options, error : outError)
    }
}
impl AVMutableMovie_AVMutableMovieMovieLevelEditing for AVMutableMovie {}
pub trait AVMutableMovie_AVMutableMovieMovieLevelEditing: Sized + std::ops::Deref {
    unsafe fn insertTimeRange_ofAsset_atTime_copySampleData_error_(
        &self,
        timeRange: CMTimeRange,
        asset: AVAsset,
        startTime: CMTime,
        copySampleData: BOOL,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertTimeRange : timeRange, ofAsset : asset, atTime : startTime, copySampleData : copySampleData, error : outError)
    }
    unsafe fn insertEmptyTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertEmptyTimeRange : timeRange)
    }
    unsafe fn removeTimeRange_(&self, timeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeRange : timeRange)
    }
    unsafe fn scaleTimeRange_toDuration_(&self, timeRange: CMTimeRange, duration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, scaleTimeRange : timeRange, toDuration : duration)
    }
    unsafe fn isModified(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isModified)
    }
    unsafe fn setModified_(&self, modified: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setModified : modified)
    }
    unsafe fn defaultMediaDataStorage(&self) -> AVMediaDataStorage
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultMediaDataStorage)
    }
    unsafe fn setDefaultMediaDataStorage_(&self, defaultMediaDataStorage: AVMediaDataStorage)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDefaultMediaDataStorage : defaultMediaDataStorage)
    }
    unsafe fn interleavingPeriod(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, interleavingPeriod)
    }
    unsafe fn setInterleavingPeriod_(&self, interleavingPeriod: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setInterleavingPeriod : interleavingPeriod)
    }
}
impl AVMutableMovie_AVMutableMovieTrackLevelEditing for AVMutableMovie {}
pub trait AVMutableMovie_AVMutableMovieTrackLevelEditing: Sized + std::ops::Deref {
    unsafe fn mutableTrackCompatibleWithTrack_(&self, track: AVAssetTrack) -> AVMutableMovieTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mutableTrackCompatibleWithTrack : track)
    }
    unsafe fn addMutableTrackWithMediaType_copySettingsFromTrack_options_(
        &self,
        mediaType: NSString,
        track: AVAssetTrack,
        options: NSDictionary,
    ) -> AVMutableMovieTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addMutableTrackWithMediaType : mediaType, copySettingsFromTrack : track, options : options)
    }
    unsafe fn addMutableTracksCopyingSettingsFromTracks_options_(
        &self,
        existingTracks: NSArray,
        options: NSDictionary,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addMutableTracksCopyingSettingsFromTracks : existingTracks, options : options)
    }
    unsafe fn removeTrack_(&self, track: AVMovieTrack)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTrack : track)
    }
}
impl AVMutableMovie_AVMutableMovieMetadataEditing for AVMutableMovie {}
pub trait AVMutableMovie_AVMutableMovieMetadataEditing: Sized + std::ops::Deref {
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
}
impl AVMutableMovie_AVMutableMovieTrackInspection for AVMutableMovie {}
pub trait AVMutableMovie_AVMutableMovieTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVMutableMovieTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMediaDataStorage(pub id);
impl std::ops::Deref for AVMediaDataStorage {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMediaDataStorage {}
impl AVMediaDataStorage {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaDataStorage").unwrap(), alloc) })
    }
}
impl INSObject for AVMediaDataStorage {}
impl PNSObject for AVMediaDataStorage {}
impl std::convert::TryFrom<NSObject> for AVMediaDataStorage {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMediaDataStorage, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMediaDataStorage").unwrap()) };
        if is_kind_of {
            Ok(AVMediaDataStorage(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMediaDataStorage")
        }
    }
}
impl IAVMediaDataStorage for AVMediaDataStorage {}
pub trait IAVMediaDataStorage: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithURL_options_(&self, URL: NSURL, options: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL, options : options)
    }
    unsafe fn URL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URL)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMediaDataStorage").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedMovie(pub id);
impl std::ops::Deref for AVFragmentedMovie {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedMovie {}
impl AVFragmentedMovie {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedMovie").unwrap(), alloc) })
    }
}
impl PAVFragmentMinding for AVFragmentedMovie {}
impl IAVMovie for AVFragmentedMovie {}
impl PNSCopying for AVFragmentedMovie {}
impl PNSMutableCopying for AVFragmentedMovie {}
impl std::convert::TryFrom<AVMovie> for AVFragmentedMovie {
    type Error = &'static str;
    fn try_from(parent: AVMovie) -> Result<AVFragmentedMovie, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedMovie").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedMovie(parent.0))
        } else {
            Err("This AVMovie cannot be downcasted to AVFragmentedMovie")
        }
    }
}
impl IAVAsset for AVFragmentedMovie {}
impl PAVAsynchronousKeyValueLoading for AVFragmentedMovie {}
impl INSObject for AVFragmentedMovie {}
impl PNSObject for AVFragmentedMovie {}
impl IAVFragmentedMovie for AVFragmentedMovie {}
pub trait IAVFragmentedMovie: Sized + std::ops::Deref {
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
}
impl AVFragmentedMovie_AVFragmentedMovieTrackInspection for AVFragmentedMovie {}
pub trait AVFragmentedMovie_AVFragmentedMovieTrackInspection: Sized + std::ops::Deref {
    unsafe fn trackWithTrackID_(&self, trackID: CMPersistentTrackID) -> AVFragmentedMovieTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, trackWithTrackID : trackID)
    }
    unsafe fn loadTrackWithTrackID_completionHandler_(
        &self,
        trackID: CMPersistentTrackID,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTrackWithTrackID : trackID, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaType_(&self, mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaType : mediaType)
    }
    unsafe fn loadTracksWithMediaType_completionHandler_(
        &self,
        mediaType: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaType : mediaType, completionHandler : completionHandler)
    }
    unsafe fn tracksWithMediaCharacteristic_(&self, mediaCharacteristic: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, tracksWithMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn loadTracksWithMediaCharacteristic_completionHandler_(
        &self,
        mediaCharacteristic: NSString,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadTracksWithMediaCharacteristic : mediaCharacteristic, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFragmentedMovieMinder(pub id);
impl std::ops::Deref for AVFragmentedMovieMinder {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFragmentedMovieMinder {}
impl AVFragmentedMovieMinder {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedMovieMinder").unwrap(), alloc) })
    }
}
impl IAVFragmentedAssetMinder for AVFragmentedMovieMinder {}
impl From<AVFragmentedMovieMinder> for AVFragmentedAssetMinder {
    fn from(child: AVFragmentedMovieMinder) -> AVFragmentedAssetMinder {
        AVFragmentedAssetMinder(child.0)
    }
}
impl std::convert::TryFrom<AVFragmentedAssetMinder> for AVFragmentedMovieMinder {
    type Error = &'static str;
    fn try_from(parent: AVFragmentedAssetMinder) -> Result<AVFragmentedMovieMinder, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFragmentedMovieMinder").unwrap()) };
        if is_kind_of {
            Ok(AVFragmentedMovieMinder(parent.0))
        } else {
            Err("This AVFragmentedAssetMinder cannot be downcasted to AVFragmentedMovieMinder")
        }
    }
}
impl INSObject for AVFragmentedMovieMinder {}
impl PNSObject for AVFragmentedMovieMinder {}
impl IAVFragmentedMovieMinder for AVFragmentedMovieMinder {}
pub trait IAVFragmentedMovieMinder: Sized + std::ops::Deref {
    unsafe fn initWithMovie_mindingInterval_(
        &self,
        movie: AVFragmentedMovie,
        mindingInterval: NSTimeInterval,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithMovie : movie, mindingInterval : mindingInterval)
    }
    unsafe fn addFragmentedMovie_(&self, movie: AVFragmentedMovie)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addFragmentedMovie : movie)
    }
    unsafe fn removeFragmentedMovie_(&self, movie: AVFragmentedMovie)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeFragmentedMovie : movie)
    }
    unsafe fn mindingInterval(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mindingInterval)
    }
    unsafe fn setMindingInterval_(&self, mindingInterval: NSTimeInterval)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMindingInterval : mindingInterval)
    }
    unsafe fn movies(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, movies)
    }
    unsafe fn fragmentedMovieMinderWithMovie_mindingInterval_(
        movie: AVFragmentedMovie,
        mindingInterval: NSTimeInterval,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVFragmentedMovieMinder").unwrap(), fragmentedMovieMinderWithMovie : movie, mindingInterval : mindingInterval)
    }
}
impl AVMutableMovie_SynchronousAssetInterface for AVMutableMovie {}
pub trait AVMutableMovie_SynchronousAssetInterface: Sized + std::ops::Deref {
    unsafe fn metadataForFormat_(&self, format: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataForFormat : format)
    }
    unsafe fn chapterMetadataGroupsWithTitleLocale_containingItemsWithCommonKeys_(
        &self,
        locale: NSLocale,
        commonKeys: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsWithTitleLocale : locale, containingItemsWithCommonKeys : commonKeys)
    }
    unsafe fn chapterMetadataGroupsBestMatchingPreferredLanguages_(
        &self,
        preferredLanguages: NSArray,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chapterMetadataGroupsBestMatchingPreferredLanguages : preferredLanguages)
    }
    unsafe fn mediaSelectionGroupForMediaCharacteristic_(
        &self,
        mediaCharacteristic: NSString,
    ) -> AVMediaSelectionGroup
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionGroupForMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn unusedTrackID(&self) -> CMPersistentTrackID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unusedTrackID)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVOutputSettingsAssistant(pub id);
impl std::ops::Deref for AVOutputSettingsAssistant {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVOutputSettingsAssistant {}
impl AVOutputSettingsAssistant {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVOutputSettingsAssistant").unwrap(), alloc) })
    }
}
impl INSObject for AVOutputSettingsAssistant {}
impl PNSObject for AVOutputSettingsAssistant {}
impl std::convert::TryFrom<NSObject> for AVOutputSettingsAssistant {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVOutputSettingsAssistant, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVOutputSettingsAssistant").unwrap()) };
        if is_kind_of {
            Ok(AVOutputSettingsAssistant(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVOutputSettingsAssistant")
        }
    }
}
impl IAVOutputSettingsAssistant for AVOutputSettingsAssistant {}
pub trait IAVOutputSettingsAssistant: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn audioSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioSettings)
    }
    unsafe fn videoSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoSettings)
    }
    unsafe fn outputFileType(&self) -> AVFileType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputFileType)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVOutputSettingsAssistant").unwrap(), new)
    }
    unsafe fn availableOutputSettingsPresets() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVOutputSettingsAssistant").unwrap(), availableOutputSettingsPresets)
    }
    unsafe fn outputSettingsAssistantWithPreset_(presetIdentifier: NSString) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVOutputSettingsAssistant").unwrap(), outputSettingsAssistantWithPreset : presetIdentifier)
    }
}
impl AVOutputSettingsAssistant_AVOutputSettingsAssistant_SourceInformation
    for AVOutputSettingsAssistant
{
}
pub trait AVOutputSettingsAssistant_AVOutputSettingsAssistant_SourceInformation:
    Sized + std::ops::Deref
{
    unsafe fn sourceAudioFormat(&self) -> CMAudioFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceAudioFormat)
    }
    unsafe fn setSourceAudioFormat_(&self, sourceAudioFormat: CMAudioFormatDescriptionRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceAudioFormat : sourceAudioFormat)
    }
    unsafe fn sourceVideoFormat(&self) -> CMVideoFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceVideoFormat)
    }
    unsafe fn setSourceVideoFormat_(&self, sourceVideoFormat: CMVideoFormatDescriptionRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceVideoFormat : sourceVideoFormat)
    }
    unsafe fn sourceVideoAverageFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceVideoAverageFrameDuration)
    }
    unsafe fn setSourceVideoAverageFrameDuration_(&self, sourceVideoAverageFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceVideoAverageFrameDuration : sourceVideoAverageFrameDuration)
    }
    unsafe fn sourceVideoMinFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceVideoMinFrameDuration)
    }
    unsafe fn setSourceVideoMinFrameDuration_(&self, sourceVideoMinFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceVideoMinFrameDuration : sourceVideoMinFrameDuration)
    }
}
pub type AVPlayerStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayer(pub id);
impl std::ops::Deref for AVPlayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayer {}
impl AVPlayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayer {}
impl PNSObject for AVPlayer {}
impl std::convert::TryFrom<NSObject> for AVPlayer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayer, Self::Error> {
        let is_kind_of: bool = unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayer").unwrap()) };
        if is_kind_of {
            Ok(AVPlayer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayer")
        }
    }
}
impl IAVPlayer for AVPlayer {}
pub trait IAVPlayer: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithURL_(&self, URL: NSURL) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL)
    }
    unsafe fn initWithPlayerItem_(&self, item: AVPlayerItem) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPlayerItem : item)
    }
    unsafe fn status(&self) -> AVPlayerStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn playerWithURL_(URL: NSURL) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), playerWithURL : URL)
    }
    unsafe fn playerWithPlayerItem_(item: AVPlayerItem) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), playerWithPlayerItem : item)
    }
}
impl AVPlayer_AVPlayerPlaybackControl for AVPlayer {}
pub trait AVPlayer_AVPlayerPlaybackControl: Sized + std::ops::Deref {
    unsafe fn play(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, play)
    }
    unsafe fn pause(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pause)
    }
    unsafe fn playImmediatelyAtRate_(&self, rate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playImmediatelyAtRate : rate)
    }
    unsafe fn rate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rate)
    }
    unsafe fn setRate_(&self, rate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRate : rate)
    }
    unsafe fn defaultRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultRate)
    }
    unsafe fn setDefaultRate_(&self, defaultRate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDefaultRate : defaultRate)
    }
    unsafe fn timeControlStatus(&self) -> AVPlayerTimeControlStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeControlStatus)
    }
    unsafe fn reasonForWaitingToPlay(&self) -> AVPlayerWaitingReason
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reasonForWaitingToPlay)
    }
}
pub type AVPlayerTimeControlStatus = NSInteger;
pub type AVPlayerWaitingReason = NSString;
impl AVPlayer_AVPlayerItemControl for AVPlayer {}
pub trait AVPlayer_AVPlayerItemControl: Sized + std::ops::Deref {
    unsafe fn replaceCurrentItemWithPlayerItem_(&self, item: AVPlayerItem)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replaceCurrentItemWithPlayerItem : item)
    }
    unsafe fn currentItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentItem)
    }
    unsafe fn actionAtItemEnd(&self) -> AVPlayerActionAtItemEnd
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, actionAtItemEnd)
    }
    unsafe fn setActionAtItemEnd_(&self, actionAtItemEnd: AVPlayerActionAtItemEnd)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActionAtItemEnd : actionAtItemEnd)
    }
}
pub type AVPlayerActionAtItemEnd = NSInteger;
impl AVPlayer_AVPlayerTimeControl for AVPlayer {}
pub trait AVPlayer_AVPlayerTimeControl: Sized + std::ops::Deref {
    unsafe fn currentTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentTime)
    }
    unsafe fn seekToDate_(&self, date: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToDate : date)
    }
    unsafe fn seekToDate_completionHandler_(
        &self,
        date: NSDate,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToDate : date, completionHandler : completionHandler)
    }
    unsafe fn seekToTime_(&self, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time)
    }
    unsafe fn seekToTime_toleranceBefore_toleranceAfter_(
        &self,
        time: CMTime,
        toleranceBefore: CMTime,
        toleranceAfter: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, toleranceBefore : toleranceBefore, toleranceAfter : toleranceAfter)
    }
    unsafe fn seekToTime_completionHandler_(
        &self,
        time: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, completionHandler : completionHandler)
    }
    unsafe fn seekToTime_toleranceBefore_toleranceAfter_completionHandler_(
        &self,
        time: CMTime,
        toleranceBefore: CMTime,
        toleranceAfter: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, toleranceBefore : toleranceBefore, toleranceAfter : toleranceAfter, completionHandler : completionHandler)
    }
}
impl AVPlayer_AVPlayerAdvancedRateControl for AVPlayer {}
pub trait AVPlayer_AVPlayerAdvancedRateControl: Sized + std::ops::Deref {
    unsafe fn setRate_time_atHostTime_(&self, rate: f32, itemTime: CMTime, hostClockTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRate : rate, time : itemTime, atHostTime : hostClockTime)
    }
    unsafe fn prerollAtRate_completionHandler_(
        &self,
        rate: f32,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, prerollAtRate : rate, completionHandler : completionHandler)
    }
    unsafe fn cancelPendingPrerolls(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelPendingPrerolls)
    }
    unsafe fn automaticallyWaitsToMinimizeStalling(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyWaitsToMinimizeStalling)
    }
    unsafe fn setAutomaticallyWaitsToMinimizeStalling_(
        &self,
        automaticallyWaitsToMinimizeStalling: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyWaitsToMinimizeStalling : automaticallyWaitsToMinimizeStalling)
    }
    unsafe fn sourceClock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceClock)
    }
    unsafe fn setSourceClock_(&self, sourceClock: CMClockRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSourceClock : sourceClock)
    }
}
impl AVPlayer_AVPlayerTimeObservation for AVPlayer {}
pub trait AVPlayer_AVPlayerTimeObservation: Sized + std::ops::Deref {
    unsafe fn addPeriodicTimeObserverForInterval_queue_usingBlock_(
        &self,
        interval: CMTime,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addPeriodicTimeObserverForInterval : interval, queue : queue, usingBlock : block)
    }
    unsafe fn addBoundaryTimeObserverForTimes_queue_usingBlock_(
        &self,
        times: NSArray,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addBoundaryTimeObserverForTimes : times, queue : queue, usingBlock : block)
    }
    unsafe fn removeTimeObserver_(&self, observer: id)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeObserver : observer)
    }
}
impl AVPlayer_AVPlayerMediaControl for AVPlayer {}
pub trait AVPlayer_AVPlayerMediaControl: Sized + std::ops::Deref {
    unsafe fn volume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, volume)
    }
    unsafe fn setVolume_(&self, volume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolume : volume)
    }
    unsafe fn isMuted(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMuted)
    }
    unsafe fn setMuted_(&self, muted: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMuted : muted)
    }
}
impl AVPlayer_AVPlayerAutomaticMediaSelection for AVPlayer {}
pub trait AVPlayer_AVPlayerAutomaticMediaSelection: Sized + std::ops::Deref {
    unsafe fn setMediaSelectionCriteria_forMediaCharacteristic_(
        &self,
        criteria: AVPlayerMediaSelectionCriteria,
        mediaCharacteristic: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMediaSelectionCriteria : criteria, forMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn mediaSelectionCriteriaForMediaCharacteristic_(
        &self,
        mediaCharacteristic: NSString,
    ) -> AVPlayerMediaSelectionCriteria
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mediaSelectionCriteriaForMediaCharacteristic : mediaCharacteristic)
    }
    unsafe fn appliesMediaSelectionCriteriaAutomatically(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, appliesMediaSelectionCriteriaAutomatically)
    }
    unsafe fn setAppliesMediaSelectionCriteriaAutomatically_(
        &self,
        appliesMediaSelectionCriteriaAutomatically: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAppliesMediaSelectionCriteriaAutomatically : appliesMediaSelectionCriteriaAutomatically)
    }
}
impl AVPlayer_AVPlayerAudioDeviceSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerAudioDeviceSupport: Sized + std::ops::Deref {
    unsafe fn audioOutputDeviceUniqueID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioOutputDeviceUniqueID)
    }
    unsafe fn setAudioOutputDeviceUniqueID_(&self, audioOutputDeviceUniqueID: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioOutputDeviceUniqueID : audioOutputDeviceUniqueID)
    }
}
impl AVPlayer_AVPlayerExternalPlaybackSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerExternalPlaybackSupport: Sized + std::ops::Deref {
    unsafe fn allowsExternalPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowsExternalPlayback)
    }
    unsafe fn setAllowsExternalPlayback_(&self, allowsExternalPlayback: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAllowsExternalPlayback : allowsExternalPlayback)
    }
    unsafe fn isExternalPlaybackActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isExternalPlaybackActive)
    }
    unsafe fn usesExternalPlaybackWhileExternalScreenIsActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, usesExternalPlaybackWhileExternalScreenIsActive)
    }
    unsafe fn setUsesExternalPlaybackWhileExternalScreenIsActive_(
        &self,
        usesExternalPlaybackWhileExternalScreenIsActive: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setUsesExternalPlaybackWhileExternalScreenIsActive : usesExternalPlaybackWhileExternalScreenIsActive)
    }
    unsafe fn externalPlaybackVideoGravity(&self) -> AVLayerVideoGravity
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, externalPlaybackVideoGravity)
    }
    unsafe fn setExternalPlaybackVideoGravity_(&self, externalPlaybackVideoGravity: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExternalPlaybackVideoGravity : externalPlaybackVideoGravity)
    }
}
impl AVPlayer_AVPlayerProtectedContent for AVPlayer {}
pub trait AVPlayer_AVPlayerProtectedContent: Sized + std::ops::Deref {
    unsafe fn outputObscuredDueToInsufficientExternalProtection(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputObscuredDueToInsufficientExternalProtection)
    }
}
pub type AVPlayerHDRMode = NSInteger;
impl AVPlayer_AVPlayerPlaybackCapabilities for AVPlayer {}
pub trait AVPlayer_AVPlayerPlaybackCapabilities: Sized + std::ops::Deref {
    unsafe fn availableHDRModes() -> AVPlayerHDRMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), availableHDRModes)
    }
    unsafe fn eligibleForHDRPlayback() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), eligibleForHDRPlayback)
    }
}
impl AVPlayer_AVPlayerVideoDecoderGPUSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerVideoDecoderGPUSupport: Sized + std::ops::Deref {
    unsafe fn preferredVideoDecoderGPURegistryID(&self) -> u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVideoDecoderGPURegistryID)
    }
    unsafe fn setPreferredVideoDecoderGPURegistryID_(&self, preferredVideoDecoderGPURegistryID: u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVideoDecoderGPURegistryID : preferredVideoDecoderGPURegistryID)
    }
}
impl AVPlayer_AVPlayerVideoDisplaySleepPrevention for AVPlayer {}
pub trait AVPlayer_AVPlayerVideoDisplaySleepPrevention: Sized + std::ops::Deref {
    unsafe fn preventsDisplaySleepDuringVideoPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preventsDisplaySleepDuringVideoPlayback)
    }
    unsafe fn setPreventsDisplaySleepDuringVideoPlayback_(
        &self,
        preventsDisplaySleepDuringVideoPlayback: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreventsDisplaySleepDuringVideoPlayback : preventsDisplaySleepDuringVideoPlayback)
    }
}
impl AVPlayer_AVPlayerAutomaticBackgroundPrevention for AVPlayer {}
pub trait AVPlayer_AVPlayerAutomaticBackgroundPrevention: Sized + std::ops::Deref {
    unsafe fn preventsAutomaticBackgroundingDuringVideoPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preventsAutomaticBackgroundingDuringVideoPlayback)
    }
    unsafe fn setPreventsAutomaticBackgroundingDuringVideoPlayback_(
        &self,
        preventsAutomaticBackgroundingDuringVideoPlayback: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreventsAutomaticBackgroundingDuringVideoPlayback : preventsAutomaticBackgroundingDuringVideoPlayback)
    }
}
impl AVPlayer_AVPlayerBackgroundSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerBackgroundSupport: Sized + std::ops::Deref {
    unsafe fn audiovisualBackgroundPlaybackPolicy(
        &self,
    ) -> AVPlayerAudiovisualBackgroundPlaybackPolicy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audiovisualBackgroundPlaybackPolicy)
    }
    unsafe fn setAudiovisualBackgroundPlaybackPolicy_(
        &self,
        audiovisualBackgroundPlaybackPolicy: AVPlayerAudiovisualBackgroundPlaybackPolicy,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudiovisualBackgroundPlaybackPolicy : audiovisualBackgroundPlaybackPolicy)
    }
}
pub type AVPlayerAudiovisualBackgroundPlaybackPolicy = NSInteger;
impl AVPlayer_PlaybackCoordination for AVPlayer {}
pub trait AVPlayer_PlaybackCoordination: Sized + std::ops::Deref {
    unsafe fn playbackCoordinator(&self) -> AVPlayerPlaybackCoordinator
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackCoordinator)
    }
}
impl AVPlayer_AVPlayerOutputSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerOutputSupport: Sized + std::ops::Deref {
    unsafe fn videoOutput(&self) -> AVPlayerVideoOutput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoOutput)
    }
    unsafe fn setVideoOutput_(&self, videoOutput: AVPlayerVideoOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoOutput : videoOutput)
    }
}
pub type AVPlayerNetworkResourcePriority = NSInteger;
impl AVPlayer_AVPlayerResourceArbitrationSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerResourceArbitrationSupport: Sized + std::ops::Deref {
    unsafe fn networkResourcePriority(&self) -> AVPlayerNetworkResourcePriority
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, networkResourcePriority)
    }
    unsafe fn setNetworkResourcePriority_(
        &self,
        networkResourcePriority: AVPlayerNetworkResourcePriority,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setNetworkResourcePriority : networkResourcePriority)
    }
}
impl AVPlayer_AVPlayerSpatialAudioExperience for AVPlayer {}
pub trait AVPlayer_AVPlayerSpatialAudioExperience: Sized + std::ops::Deref {
    unsafe fn intendedSpatialAudioExperience(&self) -> CASpatialAudioExperience
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, intendedSpatialAudioExperience)
    }
    unsafe fn setIntendedSpatialAudioExperience_(
        &self,
        intendedSpatialAudioExperience: CASpatialAudioExperience,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setIntendedSpatialAudioExperience : intendedSpatialAudioExperience)
    }
}
impl AVPlayer_AVPlayerRoutingPlaybackArbitrationSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerRoutingPlaybackArbitrationSupport: Sized + std::ops::Deref {
    unsafe fn audioOutputSuppressedDueToNonMixableAudioRoute(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioOutputSuppressedDueToNonMixableAudioRoute)
    }
}
impl AVPlayer_AVPlayerObservation for AVPlayer {}
pub trait AVPlayer_AVPlayerObservation: Sized + std::ops::Deref {
    unsafe fn isObservationEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), isObservationEnabled)
    }
    unsafe fn setObservationEnabled_(observationEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayer").unwrap(), setObservationEnabled : observationEnabled)
    }
}
impl AVPlayer_AVPlayerDeprecated for AVPlayer {}
pub trait AVPlayer_AVPlayerDeprecated: Sized + std::ops::Deref {
    unsafe fn isClosedCaptionDisplayEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isClosedCaptionDisplayEnabled)
    }
    unsafe fn setClosedCaptionDisplayEnabled_(&self, closedCaptionDisplayEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setClosedCaptionDisplayEnabled : closedCaptionDisplayEnabled)
    }
    unsafe fn masterClock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, masterClock)
    }
    unsafe fn setMasterClock_(&self, masterClock: CMClockRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMasterClock : masterClock)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVQueuePlayer(pub id);
impl std::ops::Deref for AVQueuePlayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVQueuePlayer {}
impl AVQueuePlayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVQueuePlayer").unwrap(), alloc) })
    }
}
impl IAVPlayer for AVQueuePlayer {}
impl From<AVQueuePlayer> for AVPlayer {
    fn from(child: AVQueuePlayer) -> AVPlayer {
        AVPlayer(child.0)
    }
}
impl std::convert::TryFrom<AVPlayer> for AVQueuePlayer {
    type Error = &'static str;
    fn try_from(parent: AVPlayer) -> Result<AVQueuePlayer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVQueuePlayer").unwrap()) };
        if is_kind_of {
            Ok(AVQueuePlayer(parent.0))
        } else {
            Err("This AVPlayer cannot be downcasted to AVQueuePlayer")
        }
    }
}
impl INSObject for AVQueuePlayer {}
impl PNSObject for AVQueuePlayer {}
impl IAVQueuePlayer for AVQueuePlayer {}
pub trait IAVQueuePlayer: Sized + std::ops::Deref {
    unsafe fn initWithItems_(&self, items: NSArray) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithItems : items)
    }
    unsafe fn items(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, items)
    }
    unsafe fn advanceToNextItem(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, advanceToNextItem)
    }
    unsafe fn canInsertItem_afterItem_(&self, item: AVPlayerItem, afterItem: AVPlayerItem) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canInsertItem : item, afterItem : afterItem)
    }
    unsafe fn insertItem_afterItem_(&self, item: AVPlayerItem, afterItem: AVPlayerItem)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, insertItem : item, afterItem : afterItem)
    }
    unsafe fn removeItem_(&self, item: AVPlayerItem)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeItem : item)
    }
    unsafe fn removeAllItems(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, removeAllItems)
    }
    unsafe fn queuePlayerWithItems_(items: NSArray) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVQueuePlayer").unwrap(), queuePlayerWithItems : items)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlaybackCoordinationMedium(pub id);
impl std::ops::Deref for AVPlaybackCoordinationMedium {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlaybackCoordinationMedium {}
impl AVPlaybackCoordinationMedium {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlaybackCoordinationMedium").unwrap(), alloc) })
    }
}
impl INSObject for AVPlaybackCoordinationMedium {}
impl PNSObject for AVPlaybackCoordinationMedium {}
impl std::convert::TryFrom<NSObject> for AVPlaybackCoordinationMedium {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlaybackCoordinationMedium, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlaybackCoordinationMedium").unwrap()) };
        if is_kind_of {
            Ok(AVPlaybackCoordinationMedium(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlaybackCoordinationMedium")
        }
    }
}
impl IAVPlaybackCoordinationMedium for AVPlaybackCoordinationMedium {}
pub trait IAVPlaybackCoordinationMedium: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn connectedPlaybackCoordinators(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, connectedPlaybackCoordinators)
    }
}
pub type AVCoordinatedPlaybackSuspensionReason = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCoordinatedPlaybackSuspension(pub id);
impl std::ops::Deref for AVCoordinatedPlaybackSuspension {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCoordinatedPlaybackSuspension {}
impl AVCoordinatedPlaybackSuspension {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCoordinatedPlaybackSuspension").unwrap(), alloc) })
    }
}
impl INSObject for AVCoordinatedPlaybackSuspension {}
impl PNSObject for AVCoordinatedPlaybackSuspension {}
impl std::convert::TryFrom<NSObject> for AVCoordinatedPlaybackSuspension {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCoordinatedPlaybackSuspension, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCoordinatedPlaybackSuspension").unwrap())
        };
        if is_kind_of {
            Ok(AVCoordinatedPlaybackSuspension(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCoordinatedPlaybackSuspension")
        }
    }
}
impl IAVCoordinatedPlaybackSuspension for AVCoordinatedPlaybackSuspension {}
pub trait IAVCoordinatedPlaybackSuspension: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn end(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, end)
    }
    unsafe fn endProposingNewTime_(&self, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, endProposingNewTime : time)
    }
    unsafe fn reason(&self) -> AVCoordinatedPlaybackSuspensionReason
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reason)
    }
    unsafe fn beginDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, beginDate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCoordinatedPlaybackSuspension").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlaybackCoordinator(pub id);
impl std::ops::Deref for AVPlaybackCoordinator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlaybackCoordinator {}
impl AVPlaybackCoordinator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlaybackCoordinator").unwrap(), alloc) })
    }
}
impl INSObject for AVPlaybackCoordinator {}
impl PNSObject for AVPlaybackCoordinator {}
impl std::convert::TryFrom<NSObject> for AVPlaybackCoordinator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlaybackCoordinator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlaybackCoordinator").unwrap()) };
        if is_kind_of {
            Ok(AVPlaybackCoordinator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlaybackCoordinator")
        }
    }
}
impl IAVPlaybackCoordinator for AVPlaybackCoordinator {}
pub trait IAVPlaybackCoordinator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn beginSuspensionForReason_(
        &self,
        suspensionReason: NSString,
    ) -> AVCoordinatedPlaybackSuspension
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, beginSuspensionForReason : suspensionReason)
    }
    unsafe fn expectedItemTimeAtHostTime_(&self, hostClockTime: CMTime) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, expectedItemTimeAtHostTime : hostClockTime)
    }
    unsafe fn otherParticipants(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, otherParticipants)
    }
    unsafe fn suspensionReasons(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, suspensionReasons)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlaybackCoordinator").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCoordinatedPlaybackParticipant(pub id);
impl std::ops::Deref for AVCoordinatedPlaybackParticipant {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCoordinatedPlaybackParticipant {}
impl AVCoordinatedPlaybackParticipant {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCoordinatedPlaybackParticipant").unwrap(), alloc) })
    }
}
impl INSObject for AVCoordinatedPlaybackParticipant {}
impl PNSObject for AVCoordinatedPlaybackParticipant {}
impl std::convert::TryFrom<NSObject> for AVCoordinatedPlaybackParticipant {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCoordinatedPlaybackParticipant, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCoordinatedPlaybackParticipant").unwrap())
        };
        if is_kind_of {
            Ok(AVCoordinatedPlaybackParticipant(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCoordinatedPlaybackParticipant")
        }
    }
}
impl IAVCoordinatedPlaybackParticipant for AVCoordinatedPlaybackParticipant {}
pub trait IAVCoordinatedPlaybackParticipant: Sized + std::ops::Deref {
    unsafe fn suspensionReasons(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, suspensionReasons)
    }
    unsafe fn isReadyToPlay(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyToPlay)
    }
    unsafe fn identifier(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
}
impl AVPlaybackCoordinator_AVCoordinatedPlaybackPolicies for AVPlaybackCoordinator {}
pub trait AVPlaybackCoordinator_AVCoordinatedPlaybackPolicies: Sized + std::ops::Deref {
    unsafe fn setParticipantLimit_forWaitingOutSuspensionsWithReason_(
        &self,
        participantLimit: NSInteger,
        reason: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setParticipantLimit : participantLimit, forWaitingOutSuspensionsWithReason : reason)
    }
    unsafe fn participantLimitForWaitingOutSuspensionsWithReason_(
        &self,
        reason: NSString,
    ) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, participantLimitForWaitingOutSuspensionsWithReason : reason)
    }
    unsafe fn suspensionReasonsThatTriggerWaiting(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, suspensionReasonsThatTriggerWaiting)
    }
    unsafe fn setSuspensionReasonsThatTriggerWaiting_(
        &self,
        suspensionReasonsThatTriggerWaiting: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSuspensionReasonsThatTriggerWaiting : suspensionReasonsThatTriggerWaiting)
    }
    unsafe fn pauseSnapsToMediaTimeOfOriginator(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pauseSnapsToMediaTimeOfOriginator)
    }
    unsafe fn setPauseSnapsToMediaTimeOfOriginator_(&self, pauseSnapsToMediaTimeOfOriginator: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPauseSnapsToMediaTimeOfOriginator : pauseSnapsToMediaTimeOfOriginator)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerPlaybackCoordinator(pub id);
impl std::ops::Deref for AVPlayerPlaybackCoordinator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerPlaybackCoordinator {}
impl AVPlayerPlaybackCoordinator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerPlaybackCoordinator").unwrap(), alloc) })
    }
}
impl IAVPlaybackCoordinator for AVPlayerPlaybackCoordinator {}
impl From<AVPlayerPlaybackCoordinator> for AVPlaybackCoordinator {
    fn from(child: AVPlayerPlaybackCoordinator) -> AVPlaybackCoordinator {
        AVPlaybackCoordinator(child.0)
    }
}
impl std::convert::TryFrom<AVPlaybackCoordinator> for AVPlayerPlaybackCoordinator {
    type Error = &'static str;
    fn try_from(parent: AVPlaybackCoordinator) -> Result<AVPlayerPlaybackCoordinator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerPlaybackCoordinator").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerPlaybackCoordinator(parent.0))
        } else {
            Err("This AVPlaybackCoordinator cannot be downcasted to AVPlayerPlaybackCoordinator")
        }
    }
}
impl INSObject for AVPlayerPlaybackCoordinator {}
impl PNSObject for AVPlayerPlaybackCoordinator {}
impl IAVPlayerPlaybackCoordinator for AVPlayerPlaybackCoordinator {}
pub trait IAVPlayerPlaybackCoordinator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn player(&self) -> AVPlayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, player)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn setDelegate_(&self, delegate: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerPlaybackCoordinator").unwrap(), new)
    }
}
impl AVPlayerPlaybackCoordinator_AVPlaybackCoordinationMediumSupport
    for AVPlayerPlaybackCoordinator
{
}
pub trait AVPlayerPlaybackCoordinator_AVPlaybackCoordinationMediumSupport:
    Sized + std::ops::Deref
{
    unsafe fn coordinateUsingCoordinationMedium_error_(
        &self,
        coordinationMedium: AVPlaybackCoordinationMedium,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, coordinateUsingCoordinationMedium : coordinationMedium, error : outError)
    }
    unsafe fn playbackCoordinationMedium(&self) -> AVPlaybackCoordinationMedium
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackCoordinationMedium)
    }
}
pub trait PAVPlayerPlaybackCoordinatorDelegate: Sized + std::ops::Deref {
    unsafe fn playbackCoordinator_identifierForPlayerItem_(
        &self,
        coordinator: AVPlayerPlaybackCoordinator,
        playerItem: AVPlayerItem,
    ) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, identifierForPlayerItem : playerItem)
    }
    unsafe fn playbackCoordinator_interstitialTimeRangesForPlayerItem_(
        &self,
        coordinator: AVPlayerPlaybackCoordinator,
        playerItem: AVPlayerItem,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, interstitialTimeRangesForPlayerItem : playerItem)
    }
}
pub type AVDelegatingPlaybackCoordinatorRateChangeOptions = NSUInteger;
pub type AVDelegatingPlaybackCoordinatorSeekOptions = NSUInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinator(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinator {}
impl AVDelegatingPlaybackCoordinator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinator").unwrap(), alloc) })
    }
}
impl IAVPlaybackCoordinator for AVDelegatingPlaybackCoordinator {}
impl std::convert::TryFrom<AVPlaybackCoordinator> for AVDelegatingPlaybackCoordinator {
    type Error = &'static str;
    fn try_from(
        parent: AVPlaybackCoordinator,
    ) -> Result<AVDelegatingPlaybackCoordinator, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinator").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinator(parent.0))
        } else {
            Err ("This AVPlaybackCoordinator cannot be downcasted to AVDelegatingPlaybackCoordinator" ,)
        }
    }
}
impl INSObject for AVDelegatingPlaybackCoordinator {}
impl PNSObject for AVDelegatingPlaybackCoordinator {}
impl IAVDelegatingPlaybackCoordinator for AVDelegatingPlaybackCoordinator {}
pub trait IAVDelegatingPlaybackCoordinator: Sized + std::ops::Deref {
    unsafe fn initWithPlaybackControlDelegate_(
        &self,
        playbackControlDelegate: *mut u64,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPlaybackControlDelegate : playbackControlDelegate)
    }
    unsafe fn coordinateRateChangeToRate_options_(
        &self,
        rate: f32,
        options: AVDelegatingPlaybackCoordinatorRateChangeOptions,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, coordinateRateChangeToRate : rate, options : options)
    }
    unsafe fn coordinateSeekToTime_options_(
        &self,
        time: CMTime,
        options: AVDelegatingPlaybackCoordinatorSeekOptions,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, coordinateSeekToTime : time, options : options)
    }
    unsafe fn transitionToItemWithIdentifier_proposingInitialTimingBasedOnTimebase_(
        &self,
        itemIdentifier: NSString,
        snapshotTimebase: CMTimebaseRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, transitionToItemWithIdentifier : itemIdentifier, proposingInitialTimingBasedOnTimebase : snapshotTimebase)
    }
    unsafe fn reapplyCurrentItemStateToPlaybackControlDelegate(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reapplyCurrentItemStateToPlaybackControlDelegate)
    }
    unsafe fn playbackControlDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackControlDelegate)
    }
    unsafe fn currentItemIdentifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentItemIdentifier)
    }
}
pub trait PAVPlaybackCoordinatorPlaybackControlDelegate: Sized + std::ops::Deref {
    unsafe fn playbackCoordinator_didIssuePlayCommand_completionHandler_(
        &self,
        coordinator: AVDelegatingPlaybackCoordinator,
        playCommand: AVDelegatingPlaybackCoordinatorPlayCommand,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, didIssuePlayCommand : playCommand, completionHandler : completionHandler)
    }
    unsafe fn playbackCoordinator_didIssuePauseCommand_completionHandler_(
        &self,
        coordinator: AVDelegatingPlaybackCoordinator,
        pauseCommand: AVDelegatingPlaybackCoordinatorPauseCommand,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, didIssuePauseCommand : pauseCommand, completionHandler : completionHandler)
    }
    unsafe fn playbackCoordinator_didIssueSeekCommand_completionHandler_(
        &self,
        coordinator: AVDelegatingPlaybackCoordinator,
        seekCommand: AVDelegatingPlaybackCoordinatorSeekCommand,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, didIssueSeekCommand : seekCommand, completionHandler : completionHandler)
    }
    unsafe fn playbackCoordinator_didIssueBufferingCommand_completionHandler_(
        &self,
        coordinator: AVDelegatingPlaybackCoordinator,
        bufferingCommand: AVDelegatingPlaybackCoordinatorBufferingCommand,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, playbackCoordinator : coordinator, didIssueBufferingCommand : bufferingCommand, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinatorPlaybackControlCommand(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {}
impl AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlaybackControlCommand").unwrap(), alloc)
        })
    }
}
impl INSObject for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {}
impl PNSObject for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {}
impl std::convert::TryFrom<NSObject> for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVDelegatingPlaybackCoordinatorPlaybackControlCommand, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlaybackControlCommand").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinatorPlaybackControlCommand(
                parent.0,
            ))
        } else {
            Err ("This NSObject cannot be downcasted to AVDelegatingPlaybackCoordinatorPlaybackControlCommand" ,)
        }
    }
}
impl IAVDelegatingPlaybackCoordinatorPlaybackControlCommand
    for AVDelegatingPlaybackCoordinatorPlaybackControlCommand
{
}
pub trait IAVDelegatingPlaybackCoordinatorPlaybackControlCommand: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn originator(&self) -> AVCoordinatedPlaybackParticipant
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, originator)
    }
    unsafe fn expectedCurrentItemIdentifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expectedCurrentItemIdentifier)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlaybackControlCommand").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinatorPlayCommand(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinatorPlayCommand {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinatorPlayCommand {}
impl AVDelegatingPlaybackCoordinatorPlayCommand {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlayCommand").unwrap(), alloc) })
    }
}
impl IAVDelegatingPlaybackCoordinatorPlaybackControlCommand
    for AVDelegatingPlaybackCoordinatorPlayCommand
{
}
impl From<AVDelegatingPlaybackCoordinatorPlayCommand>
    for AVDelegatingPlaybackCoordinatorPlaybackControlCommand
{
    fn from(
        child: AVDelegatingPlaybackCoordinatorPlayCommand,
    ) -> AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
        AVDelegatingPlaybackCoordinatorPlaybackControlCommand(child.0)
    }
}
impl std::convert::TryFrom<AVDelegatingPlaybackCoordinatorPlaybackControlCommand>
    for AVDelegatingPlaybackCoordinatorPlayCommand
{
    type Error = &'static str;
    fn try_from(
        parent: AVDelegatingPlaybackCoordinatorPlaybackControlCommand,
    ) -> Result<AVDelegatingPlaybackCoordinatorPlayCommand, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlayCommand").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinatorPlayCommand(parent.0))
        } else {
            Err ("This AVDelegatingPlaybackCoordinatorPlaybackControlCommand cannot be downcasted to AVDelegatingPlaybackCoordinatorPlayCommand" ,)
        }
    }
}
impl INSObject for AVDelegatingPlaybackCoordinatorPlayCommand {}
impl PNSObject for AVDelegatingPlaybackCoordinatorPlayCommand {}
impl IAVDelegatingPlaybackCoordinatorPlayCommand for AVDelegatingPlaybackCoordinatorPlayCommand {}
pub trait IAVDelegatingPlaybackCoordinatorPlayCommand: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn rate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rate)
    }
    unsafe fn itemTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, itemTime)
    }
    unsafe fn hostClockTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hostClockTime)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPlayCommand").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinatorBufferingCommand(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinatorBufferingCommand {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinatorBufferingCommand {}
impl AVDelegatingPlaybackCoordinatorBufferingCommand {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorBufferingCommand").unwrap(), alloc)
        })
    }
}
impl IAVDelegatingPlaybackCoordinatorPlaybackControlCommand
    for AVDelegatingPlaybackCoordinatorBufferingCommand
{
}
impl std::convert::TryFrom<AVDelegatingPlaybackCoordinatorPlaybackControlCommand>
    for AVDelegatingPlaybackCoordinatorBufferingCommand
{
    type Error = &'static str;
    fn try_from(
        parent: AVDelegatingPlaybackCoordinatorPlaybackControlCommand,
    ) -> Result<AVDelegatingPlaybackCoordinatorBufferingCommand, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorBufferingCommand").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinatorBufferingCommand(parent.0))
        } else {
            Err ("This AVDelegatingPlaybackCoordinatorPlaybackControlCommand cannot be downcasted to AVDelegatingPlaybackCoordinatorBufferingCommand" ,)
        }
    }
}
impl INSObject for AVDelegatingPlaybackCoordinatorBufferingCommand {}
impl PNSObject for AVDelegatingPlaybackCoordinatorBufferingCommand {}
impl IAVDelegatingPlaybackCoordinatorBufferingCommand
    for AVDelegatingPlaybackCoordinatorBufferingCommand
{
}
pub trait IAVDelegatingPlaybackCoordinatorBufferingCommand: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn anticipatedPlaybackRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, anticipatedPlaybackRate)
    }
    unsafe fn completionDueDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, completionDueDate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorBufferingCommand").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinatorPauseCommand(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinatorPauseCommand {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinatorPauseCommand {}
impl AVDelegatingPlaybackCoordinatorPauseCommand {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPauseCommand").unwrap(), alloc) })
    }
}
impl IAVDelegatingPlaybackCoordinatorPlaybackControlCommand
    for AVDelegatingPlaybackCoordinatorPauseCommand
{
}
impl std::convert::TryFrom<AVDelegatingPlaybackCoordinatorPlaybackControlCommand>
    for AVDelegatingPlaybackCoordinatorPauseCommand
{
    type Error = &'static str;
    fn try_from(
        parent: AVDelegatingPlaybackCoordinatorPlaybackControlCommand,
    ) -> Result<AVDelegatingPlaybackCoordinatorPauseCommand, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPauseCommand").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinatorPauseCommand(parent.0))
        } else {
            Err ("This AVDelegatingPlaybackCoordinatorPlaybackControlCommand cannot be downcasted to AVDelegatingPlaybackCoordinatorPauseCommand" ,)
        }
    }
}
impl INSObject for AVDelegatingPlaybackCoordinatorPauseCommand {}
impl PNSObject for AVDelegatingPlaybackCoordinatorPauseCommand {}
impl IAVDelegatingPlaybackCoordinatorPauseCommand for AVDelegatingPlaybackCoordinatorPauseCommand {}
pub trait IAVDelegatingPlaybackCoordinatorPauseCommand: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn shouldBufferInAnticipationOfPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldBufferInAnticipationOfPlayback)
    }
    unsafe fn anticipatedPlaybackRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, anticipatedPlaybackRate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorPauseCommand").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDelegatingPlaybackCoordinatorSeekCommand(pub id);
impl std::ops::Deref for AVDelegatingPlaybackCoordinatorSeekCommand {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDelegatingPlaybackCoordinatorSeekCommand {}
impl AVDelegatingPlaybackCoordinatorSeekCommand {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorSeekCommand").unwrap(), alloc) })
    }
}
impl IAVDelegatingPlaybackCoordinatorPlaybackControlCommand
    for AVDelegatingPlaybackCoordinatorSeekCommand
{
}
impl std::convert::TryFrom<AVDelegatingPlaybackCoordinatorPlaybackControlCommand>
    for AVDelegatingPlaybackCoordinatorSeekCommand
{
    type Error = &'static str;
    fn try_from(
        parent: AVDelegatingPlaybackCoordinatorPlaybackControlCommand,
    ) -> Result<AVDelegatingPlaybackCoordinatorSeekCommand, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorSeekCommand").unwrap())
        };
        if is_kind_of {
            Ok(AVDelegatingPlaybackCoordinatorSeekCommand(parent.0))
        } else {
            Err ("This AVDelegatingPlaybackCoordinatorPlaybackControlCommand cannot be downcasted to AVDelegatingPlaybackCoordinatorSeekCommand" ,)
        }
    }
}
impl INSObject for AVDelegatingPlaybackCoordinatorSeekCommand {}
impl PNSObject for AVDelegatingPlaybackCoordinatorSeekCommand {}
impl IAVDelegatingPlaybackCoordinatorSeekCommand for AVDelegatingPlaybackCoordinatorSeekCommand {}
pub trait IAVDelegatingPlaybackCoordinatorSeekCommand: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn itemTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, itemTime)
    }
    unsafe fn shouldBufferInAnticipationOfPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldBufferInAnticipationOfPlayback)
    }
    unsafe fn anticipatedPlaybackRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, anticipatedPlaybackRate)
    }
    unsafe fn completionDueDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, completionDueDate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDelegatingPlaybackCoordinatorSeekCommand").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerVideoOutput(pub id);
impl std::ops::Deref for AVPlayerVideoOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerVideoOutput {}
impl AVPlayerVideoOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerVideoOutput").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerVideoOutput {}
impl PNSObject for AVPlayerVideoOutput {}
impl std::convert::TryFrom<NSObject> for AVPlayerVideoOutput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerVideoOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerVideoOutput").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerVideoOutput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerVideoOutput")
        }
    }
}
impl IAVPlayerVideoOutput for AVPlayerVideoOutput {}
pub trait IAVPlayerVideoOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithSpecification_(
        &self,
        specification: AVVideoOutputSpecification,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithSpecification : specification)
    }
    unsafe fn copyTaggedBufferGroupForHostTime_presentationTimeStamp_activeConfiguration_(
        &self,
        hostTime: CMTime,
        presentationTimeStampOut: *mut CMTime,
        activeConfigurationOut: *mut AVPlayerVideoOutputConfiguration,
    ) -> CMTaggedBufferGroupRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, copyTaggedBufferGroupForHostTime : hostTime, presentationTimeStamp : presentationTimeStampOut, activeConfiguration : activeConfigurationOut)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerVideoOutput").unwrap(), new)
    }
}
pub type CMTagCollectionVideoOutputPreset = u32;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoOutputSpecification(pub id);
impl std::ops::Deref for AVVideoOutputSpecification {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoOutputSpecification {}
impl AVVideoOutputSpecification {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoOutputSpecification").unwrap(), alloc) })
    }
}
impl PNSCopying for AVVideoOutputSpecification {}
impl INSObject for AVVideoOutputSpecification {}
impl PNSObject for AVVideoOutputSpecification {}
impl std::convert::TryFrom<NSObject> for AVVideoOutputSpecification {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoOutputSpecification, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoOutputSpecification").unwrap()) };
        if is_kind_of {
            Ok(AVVideoOutputSpecification(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoOutputSpecification")
        }
    }
}
impl IAVVideoOutputSpecification for AVVideoOutputSpecification {}
pub trait IAVVideoOutputSpecification: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithTagCollections_(&self, tagCollections: NSArray) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithTagCollections : tagCollections)
    }
    unsafe fn setOutputPixelBufferAttributes_forTagCollection_(
        &self,
        pixelBufferAttributes: NSDictionary,
        tagCollection: CMTagCollectionRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputPixelBufferAttributes : pixelBufferAttributes, forTagCollection : tagCollection)
    }
    unsafe fn setOutputSettings_forTagCollection_(
        &self,
        outputSettings: NSDictionary,
        tagCollection: CMTagCollectionRef,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputSettings : outputSettings, forTagCollection : tagCollection)
    }
    unsafe fn preferredTagCollections(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTagCollections)
    }
    unsafe fn defaultPixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultPixelBufferAttributes)
    }
    unsafe fn setDefaultPixelBufferAttributes_(&self, defaultPixelBufferAttributes: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDefaultPixelBufferAttributes : defaultPixelBufferAttributes)
    }
    unsafe fn defaultOutputSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultOutputSettings)
    }
    unsafe fn setDefaultOutputSettings_(&self, defaultOutputSettings: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDefaultOutputSettings : defaultOutputSettings)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoOutputSpecification").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerVideoOutputConfiguration(pub id);
impl std::ops::Deref for AVPlayerVideoOutputConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerVideoOutputConfiguration {}
impl AVPlayerVideoOutputConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerVideoOutputConfiguration").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerVideoOutputConfiguration {}
impl PNSObject for AVPlayerVideoOutputConfiguration {}
impl std::convert::TryFrom<NSObject> for AVPlayerVideoOutputConfiguration {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerVideoOutputConfiguration, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerVideoOutputConfiguration").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerVideoOutputConfiguration(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerVideoOutputConfiguration")
        }
    }
}
impl IAVPlayerVideoOutputConfiguration for AVPlayerVideoOutputConfiguration {}
pub trait IAVPlayerVideoOutputConfiguration: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn sourcePlayerItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourcePlayerItem)
    }
    unsafe fn dataChannelDescriptions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataChannelDescriptions)
    }
    unsafe fn preferredTransform(&self) -> CGAffineTransform
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredTransform)
    }
    unsafe fn activationTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activationTime)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerVideoOutputConfiguration").unwrap(), new)
    }
}
pub type AVPlayerItemStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItem(pub id);
impl std::ops::Deref for AVPlayerItem {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItem {}
impl AVPlayerItem {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerItem {}
impl INSObject for AVPlayerItem {}
impl PNSObject for AVPlayerItem {}
impl std::convert::TryFrom<NSObject> for AVPlayerItem {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItem, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItem(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItem")
        }
    }
}
impl IAVPlayerItem for AVPlayerItem {}
pub trait IAVPlayerItem: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithURL_(&self, URL: NSURL) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithURL : URL)
    }
    unsafe fn initWithAsset_(&self, asset: AVAsset) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset)
    }
    unsafe fn initWithAsset_automaticallyLoadedAssetKeys_(
        &self,
        asset: AVAsset,
        automaticallyLoadedAssetKeys: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset, automaticallyLoadedAssetKeys : automaticallyLoadedAssetKeys)
    }
    unsafe fn copyWithZone_(&self, zone: *mut NSZone) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, copyWithZone : zone)
    }
    unsafe fn copy(&self) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copy)
    }
    unsafe fn status(&self) -> AVPlayerItemStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap(), new)
    }
    unsafe fn playerItemWithURL_(URL: NSURL) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap(), playerItemWithURL : URL)
    }
    unsafe fn playerItemWithAsset_(asset: AVAsset) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap(), playerItemWithAsset : asset)
    }
    unsafe fn playerItemWithAsset_automaticallyLoadedAssetKeys_(
        asset: AVAsset,
        automaticallyLoadedAssetKeys: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItem").unwrap(), playerItemWithAsset : asset, automaticallyLoadedAssetKeys : automaticallyLoadedAssetKeys)
    }
}
impl AVPlayerItem_AVPlayerItemInspection for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemInspection: Sized + std::ops::Deref {
    unsafe fn asset(&self) -> AVAsset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, asset)
    }
    unsafe fn tracks(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, tracks)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn presentationSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, presentationSize)
    }
    unsafe fn timedMetadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timedMetadata)
    }
    unsafe fn automaticallyLoadedAssetKeys(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyLoadedAssetKeys)
    }
}
impl AVPlayerItem_AVPlayerItemRateAndSteppingSupport for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemRateAndSteppingSupport: Sized + std::ops::Deref {
    unsafe fn canPlayFastForward(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPlayFastForward)
    }
    unsafe fn canPlaySlowForward(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPlaySlowForward)
    }
    unsafe fn canPlayReverse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPlayReverse)
    }
    unsafe fn canPlaySlowReverse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPlaySlowReverse)
    }
    unsafe fn canPlayFastReverse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPlayFastReverse)
    }
    unsafe fn canStepForward(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canStepForward)
    }
    unsafe fn canStepBackward(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canStepBackward)
    }
    unsafe fn configuredTimeOffsetFromLive(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, configuredTimeOffsetFromLive)
    }
    unsafe fn setConfiguredTimeOffsetFromLive_(&self, configuredTimeOffsetFromLive: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConfiguredTimeOffsetFromLive : configuredTimeOffsetFromLive)
    }
    unsafe fn recommendedTimeOffsetFromLive(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recommendedTimeOffsetFromLive)
    }
    unsafe fn automaticallyPreservesTimeOffsetFromLive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyPreservesTimeOffsetFromLive)
    }
    unsafe fn setAutomaticallyPreservesTimeOffsetFromLive_(
        &self,
        automaticallyPreservesTimeOffsetFromLive: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyPreservesTimeOffsetFromLive : automaticallyPreservesTimeOffsetFromLive)
    }
}
impl AVPlayerItem_AVPlayerItemTimeControl for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemTimeControl: Sized + std::ops::Deref {
    unsafe fn currentTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentTime)
    }
    unsafe fn seekToTime_completionHandler_(
        &self,
        time: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, completionHandler : completionHandler)
    }
    unsafe fn seekToTime_toleranceBefore_toleranceAfter_completionHandler_(
        &self,
        time: CMTime,
        toleranceBefore: CMTime,
        toleranceAfter: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, toleranceBefore : toleranceBefore, toleranceAfter : toleranceAfter, completionHandler : completionHandler)
    }
    unsafe fn cancelPendingSeeks(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelPendingSeeks)
    }
    unsafe fn currentDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentDate)
    }
    unsafe fn seekToDate_completionHandler_(
        &self,
        date: NSDate,
        completionHandler: *mut ::std::os::raw::c_void,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToDate : date, completionHandler : completionHandler)
    }
    unsafe fn stepByCount_(&self, stepCount: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stepByCount : stepCount)
    }
    unsafe fn forwardPlaybackEndTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, forwardPlaybackEndTime)
    }
    unsafe fn setForwardPlaybackEndTime_(&self, forwardPlaybackEndTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setForwardPlaybackEndTime : forwardPlaybackEndTime)
    }
    unsafe fn reversePlaybackEndTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reversePlaybackEndTime)
    }
    unsafe fn setReversePlaybackEndTime_(&self, reversePlaybackEndTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setReversePlaybackEndTime : reversePlaybackEndTime)
    }
    unsafe fn seekableTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, seekableTimeRanges)
    }
    unsafe fn timebase(&self) -> CMTimebaseRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timebase)
    }
}
impl AVPlayerItem_AVPlayerItemVisualPresentation for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemVisualPresentation: Sized + std::ops::Deref {
    unsafe fn videoComposition(&self) -> AVVideoComposition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoComposition)
    }
    unsafe fn setVideoComposition_(&self, videoComposition: AVVideoComposition)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoComposition : videoComposition)
    }
    unsafe fn customVideoCompositor(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, customVideoCompositor)
    }
    unsafe fn seekingWaitsForVideoCompositionRendering(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, seekingWaitsForVideoCompositionRendering)
    }
    unsafe fn setSeekingWaitsForVideoCompositionRendering_(
        &self,
        seekingWaitsForVideoCompositionRendering: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSeekingWaitsForVideoCompositionRendering : seekingWaitsForVideoCompositionRendering)
    }
    unsafe fn textStyleRules(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textStyleRules)
    }
    unsafe fn setTextStyleRules_(&self, textStyleRules: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTextStyleRules : textStyleRules)
    }
    unsafe fn videoApertureMode(&self) -> AVVideoApertureMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoApertureMode)
    }
    unsafe fn setVideoApertureMode_(&self, videoApertureMode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoApertureMode : videoApertureMode)
    }
    unsafe fn appliesPerFrameHDRDisplayMetadata(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, appliesPerFrameHDRDisplayMetadata)
    }
    unsafe fn setAppliesPerFrameHDRDisplayMetadata_(&self, appliesPerFrameHDRDisplayMetadata: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAppliesPerFrameHDRDisplayMetadata : appliesPerFrameHDRDisplayMetadata)
    }
}
impl AVPlayerItem_AVPlayerItemAudioProcessing for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemAudioProcessing: Sized + std::ops::Deref {
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn isAudioSpatializationAllowed(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAudioSpatializationAllowed)
    }
    unsafe fn setAudioSpatializationAllowed_(&self, audioSpatializationAllowed: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioSpatializationAllowed : audioSpatializationAllowed)
    }
    unsafe fn allowedAudioSpatializationFormats(&self) -> AVAudioSpatializationFormats
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowedAudioSpatializationFormats)
    }
    unsafe fn setAllowedAudioSpatializationFormats_(
        &self,
        allowedAudioSpatializationFormats: AVAudioSpatializationFormats,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAllowedAudioSpatializationFormats : allowedAudioSpatializationFormats)
    }
    unsafe fn audioMix(&self) -> AVAudioMix
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioMix)
    }
    unsafe fn setAudioMix_(&self, audioMix: AVAudioMix)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioMix : audioMix)
    }
}
impl AVPlayerItem_AVPlayerItemPlayability for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemPlayability: Sized + std::ops::Deref {
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn isPlaybackLikelyToKeepUp(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlaybackLikelyToKeepUp)
    }
    unsafe fn isPlaybackBufferFull(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlaybackBufferFull)
    }
    unsafe fn isPlaybackBufferEmpty(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPlaybackBufferEmpty)
    }
    unsafe fn canUseNetworkResourcesForLiveStreamingWhilePaused(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canUseNetworkResourcesForLiveStreamingWhilePaused)
    }
    unsafe fn setCanUseNetworkResourcesForLiveStreamingWhilePaused_(
        &self,
        canUseNetworkResourcesForLiveStreamingWhilePaused: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCanUseNetworkResourcesForLiveStreamingWhilePaused : canUseNetworkResourcesForLiveStreamingWhilePaused)
    }
    unsafe fn preferredForwardBufferDuration(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredForwardBufferDuration)
    }
    unsafe fn setPreferredForwardBufferDuration_(
        &self,
        preferredForwardBufferDuration: NSTimeInterval,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredForwardBufferDuration : preferredForwardBufferDuration)
    }
}
impl AVPlayerItem_AVPlayerItemVariantControl for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemVariantControl: Sized + std::ops::Deref {
    unsafe fn preferredPeakBitRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredPeakBitRate)
    }
    unsafe fn setPreferredPeakBitRate_(&self, preferredPeakBitRate: f64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredPeakBitRate : preferredPeakBitRate)
    }
    unsafe fn preferredPeakBitRateForExpensiveNetworks(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredPeakBitRateForExpensiveNetworks)
    }
    unsafe fn setPreferredPeakBitRateForExpensiveNetworks_(
        &self,
        preferredPeakBitRateForExpensiveNetworks: f64,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredPeakBitRateForExpensiveNetworks : preferredPeakBitRateForExpensiveNetworks)
    }
    unsafe fn preferredMaximumResolution(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMaximumResolution)
    }
    unsafe fn setPreferredMaximumResolution_(&self, preferredMaximumResolution: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMaximumResolution : preferredMaximumResolution)
    }
    unsafe fn preferredMaximumResolutionForExpensiveNetworks(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMaximumResolutionForExpensiveNetworks)
    }
    unsafe fn setPreferredMaximumResolutionForExpensiveNetworks_(
        &self,
        preferredMaximumResolutionForExpensiveNetworks: CGSize,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMaximumResolutionForExpensiveNetworks : preferredMaximumResolutionForExpensiveNetworks)
    }
    unsafe fn startsOnFirstEligibleVariant(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startsOnFirstEligibleVariant)
    }
    unsafe fn setStartsOnFirstEligibleVariant_(&self, startsOnFirstEligibleVariant: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setStartsOnFirstEligibleVariant : startsOnFirstEligibleVariant)
    }
    unsafe fn variantPreferences(&self) -> AVVariantPreferences
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, variantPreferences)
    }
    unsafe fn setVariantPreferences_(&self, variantPreferences: AVVariantPreferences)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVariantPreferences : variantPreferences)
    }
}
pub type AVVariantPreferences = NSUInteger;
impl AVPlayerItem_AVPlayerItemMediaSelection for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemMediaSelection: Sized + std::ops::Deref {
    unsafe fn selectMediaOption_inMediaSelectionGroup_(
        &self,
        mediaSelectionOption: AVMediaSelectionOption,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectMediaOption : mediaSelectionOption, inMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn selectMediaOptionAutomaticallyInMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectMediaOptionAutomaticallyInMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn currentMediaSelection(&self) -> AVMediaSelection
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentMediaSelection)
    }
}
impl AVPlayerItem_AVPlayerItemCustomMediaSelectionScheme for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemCustomMediaSelectionScheme: Sized + std::ops::Deref {
    unsafe fn selectMediaPresentationLanguage_forMediaSelectionGroup_(
        &self,
        language: NSString,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectMediaPresentationLanguage : language, forMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn selectedMediaPresentationLanguageForMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectedMediaPresentationLanguageForMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn selectMediaPresentationSetting_forMediaSelectionGroup_(
        &self,
        mediaPresentationSetting: AVMediaPresentationSetting,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectMediaPresentationSetting : mediaPresentationSetting, forMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn selectedMediaPresentationSettingsForMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectedMediaPresentationSettingsForMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn effectiveMediaPresentationSettingsForMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, effectiveMediaPresentationSettingsForMediaSelectionGroup : mediaSelectionGroup)
    }
    unsafe fn preferredCustomMediaSelectionSchemes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredCustomMediaSelectionSchemes)
    }
    unsafe fn setPreferredCustomMediaSelectionSchemes_(
        &self,
        preferredCustomMediaSelectionSchemes: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredCustomMediaSelectionSchemes : preferredCustomMediaSelectionSchemes)
    }
}
impl AVPlayerItem_AVPlayerItemLogging for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemLogging: Sized + std::ops::Deref {
    unsafe fn accessLog(&self) -> AVPlayerItemAccessLog
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, accessLog)
    }
    unsafe fn errorLog(&self) -> AVPlayerItemErrorLog
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorLog)
    }
}
impl AVPlayerItem_AVPlayerItemOutputs for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemOutputs: Sized + std::ops::Deref {
    unsafe fn addOutput_(&self, output: AVPlayerItemOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addOutput : output)
    }
    unsafe fn removeOutput_(&self, output: AVPlayerItemOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeOutput : output)
    }
    unsafe fn outputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputs)
    }
}
impl AVPlayerItem_AVPlayerItemMediaDataCollectors for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemMediaDataCollectors: Sized + std::ops::Deref {
    unsafe fn addMediaDataCollector_(&self, collector: AVPlayerItemMediaDataCollector)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addMediaDataCollector : collector)
    }
    unsafe fn removeMediaDataCollector_(&self, collector: AVPlayerItemMediaDataCollector)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeMediaDataCollector : collector)
    }
    unsafe fn mediaDataCollectors(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaDataCollectors)
    }
}
impl AVPlayerItem_AVPlayerItemDeprecated for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemDeprecated: Sized + std::ops::Deref {
    unsafe fn seekToTime_(&self, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time)
    }
    unsafe fn seekToTime_toleranceBefore_toleranceAfter_(
        &self,
        time: CMTime,
        toleranceBefore: CMTime,
        toleranceAfter: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, toleranceBefore : toleranceBefore, toleranceAfter : toleranceAfter)
    }
    unsafe fn seekToDate_(&self, date: NSDate) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToDate : date)
    }
    unsafe fn selectedMediaOptionInMediaSelectionGroup_(
        &self,
        mediaSelectionGroup: AVMediaSelectionGroup,
    ) -> AVMediaSelectionOption
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, selectedMediaOptionInMediaSelectionGroup : mediaSelectionGroup)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemAccessLog(pub id);
impl std::ops::Deref for AVPlayerItemAccessLog {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemAccessLog {}
impl AVPlayerItemAccessLog {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLog").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerItemAccessLog {}
impl INSObject for AVPlayerItemAccessLog {}
impl PNSObject for AVPlayerItemAccessLog {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemAccessLog {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemAccessLog, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLog").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemAccessLog(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemAccessLog")
        }
    }
}
impl IAVPlayerItemAccessLog for AVPlayerItemAccessLog {}
pub trait IAVPlayerItemAccessLog: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn extendedLogData(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLogData)
    }
    unsafe fn extendedLogDataStringEncoding(&self) -> NSStringEncoding
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLogDataStringEncoding)
    }
    unsafe fn events(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, events)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLog").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemErrorLog(pub id);
impl std::ops::Deref for AVPlayerItemErrorLog {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemErrorLog {}
impl AVPlayerItemErrorLog {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLog").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerItemErrorLog {}
impl INSObject for AVPlayerItemErrorLog {}
impl PNSObject for AVPlayerItemErrorLog {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemErrorLog {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemErrorLog, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLog").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemErrorLog(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemErrorLog")
        }
    }
}
impl IAVPlayerItemErrorLog for AVPlayerItemErrorLog {}
pub trait IAVPlayerItemErrorLog: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn extendedLogData(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLogData)
    }
    unsafe fn extendedLogDataStringEncoding(&self) -> NSStringEncoding
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extendedLogDataStringEncoding)
    }
    unsafe fn events(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, events)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLog").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemAccessLogEvent(pub id);
impl std::ops::Deref for AVPlayerItemAccessLogEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemAccessLogEvent {}
impl AVPlayerItemAccessLogEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLogEvent").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerItemAccessLogEvent {}
impl INSObject for AVPlayerItemAccessLogEvent {}
impl PNSObject for AVPlayerItemAccessLogEvent {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemAccessLogEvent {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemAccessLogEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLogEvent").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemAccessLogEvent(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemAccessLogEvent")
        }
    }
}
impl IAVPlayerItemAccessLogEvent for AVPlayerItemAccessLogEvent {}
pub trait IAVPlayerItemAccessLogEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn numberOfSegmentsDownloaded(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfSegmentsDownloaded)
    }
    unsafe fn numberOfMediaRequests(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfMediaRequests)
    }
    unsafe fn playbackStartDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackStartDate)
    }
    unsafe fn URI(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URI)
    }
    unsafe fn serverAddress(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, serverAddress)
    }
    unsafe fn numberOfServerAddressChanges(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfServerAddressChanges)
    }
    unsafe fn playbackSessionID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackSessionID)
    }
    unsafe fn playbackStartOffset(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackStartOffset)
    }
    unsafe fn segmentsDownloadedDuration(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segmentsDownloadedDuration)
    }
    unsafe fn durationWatched(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, durationWatched)
    }
    unsafe fn numberOfStalls(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfStalls)
    }
    unsafe fn numberOfBytesTransferred(&self) -> ::std::os::raw::c_longlong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfBytesTransferred)
    }
    unsafe fn transferDuration(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transferDuration)
    }
    unsafe fn observedBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, observedBitrate)
    }
    unsafe fn indicatedBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, indicatedBitrate)
    }
    unsafe fn indicatedAverageBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, indicatedAverageBitrate)
    }
    unsafe fn averageVideoBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, averageVideoBitrate)
    }
    unsafe fn averageAudioBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, averageAudioBitrate)
    }
    unsafe fn numberOfDroppedVideoFrames(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfDroppedVideoFrames)
    }
    unsafe fn startupTime(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startupTime)
    }
    unsafe fn downloadOverdue(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, downloadOverdue)
    }
    unsafe fn observedMaxBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, observedMaxBitrate)
    }
    unsafe fn observedMinBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, observedMinBitrate)
    }
    unsafe fn observedBitrateStandardDeviation(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, observedBitrateStandardDeviation)
    }
    unsafe fn playbackType(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackType)
    }
    unsafe fn mediaRequestsWWAN(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaRequestsWWAN)
    }
    unsafe fn switchBitrate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, switchBitrate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemAccessLogEvent").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemErrorLogEvent(pub id);
impl std::ops::Deref for AVPlayerItemErrorLogEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemErrorLogEvent {}
impl AVPlayerItemErrorLogEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLogEvent").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerItemErrorLogEvent {}
impl INSObject for AVPlayerItemErrorLogEvent {}
impl PNSObject for AVPlayerItemErrorLogEvent {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemErrorLogEvent {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemErrorLogEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLogEvent").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemErrorLogEvent(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemErrorLogEvent")
        }
    }
}
impl IAVPlayerItemErrorLogEvent for AVPlayerItemErrorLogEvent {}
pub trait IAVPlayerItemErrorLogEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn date(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, date)
    }
    unsafe fn URI(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, URI)
    }
    unsafe fn serverAddress(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, serverAddress)
    }
    unsafe fn playbackSessionID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playbackSessionID)
    }
    unsafe fn errorStatusCode(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorStatusCode)
    }
    unsafe fn errorDomain(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorDomain)
    }
    unsafe fn errorComment(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, errorComment)
    }
    unsafe fn allHTTPResponseHeaderFields(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allHTTPResponseHeaderFields)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemErrorLogEvent").unwrap(), new)
    }
}
impl AVPlayerItem_AVMetricEventStreamPublisher for AVPlayerItem {}
pub trait AVPlayerItem_AVMetricEventStreamPublisher: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemMediaDataCollector(pub id);
impl std::ops::Deref for AVPlayerItemMediaDataCollector {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemMediaDataCollector {}
impl AVPlayerItemMediaDataCollector {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemMediaDataCollector").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemMediaDataCollector {}
impl PNSObject for AVPlayerItemMediaDataCollector {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemMediaDataCollector {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemMediaDataCollector, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemMediaDataCollector").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerItemMediaDataCollector(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemMediaDataCollector")
        }
    }
}
impl IAVPlayerItemMediaDataCollector for AVPlayerItemMediaDataCollector {}
pub trait IAVPlayerItemMediaDataCollector: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemMetadataCollector(pub id);
impl std::ops::Deref for AVPlayerItemMetadataCollector {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemMetadataCollector {}
impl AVPlayerItemMetadataCollector {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemMetadataCollector").unwrap(), alloc) })
    }
}
impl IAVPlayerItemMediaDataCollector for AVPlayerItemMetadataCollector {}
impl From<AVPlayerItemMetadataCollector> for AVPlayerItemMediaDataCollector {
    fn from(child: AVPlayerItemMetadataCollector) -> AVPlayerItemMediaDataCollector {
        AVPlayerItemMediaDataCollector(child.0)
    }
}
impl std::convert::TryFrom<AVPlayerItemMediaDataCollector> for AVPlayerItemMetadataCollector {
    type Error = &'static str;
    fn try_from(
        parent: AVPlayerItemMediaDataCollector,
    ) -> Result<AVPlayerItemMetadataCollector, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemMetadataCollector").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerItemMetadataCollector(parent.0))
        } else {
            Err ("This AVPlayerItemMediaDataCollector cannot be downcasted to AVPlayerItemMetadataCollector" ,)
        }
    }
}
impl INSObject for AVPlayerItemMetadataCollector {}
impl PNSObject for AVPlayerItemMetadataCollector {}
impl IAVPlayerItemMetadataCollector for AVPlayerItemMetadataCollector {}
pub trait IAVPlayerItemMetadataCollector: Sized + std::ops::Deref {
    unsafe fn initWithIdentifiers_classifyingLabels_(
        &self,
        identifiers: NSArray,
        classifyingLabels: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithIdentifiers : identifiers, classifyingLabels : classifyingLabels)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
}
pub trait PAVPlayerItemMetadataCollectorPushDelegate: Sized + std::ops::Deref {
    unsafe fn metadataCollector_didCollectDateRangeMetadataGroups_indexesOfNewGroups_indexesOfModifiedGroups_(
        &self,
        metadataCollector: AVPlayerItemMetadataCollector,
        metadataGroups: NSArray,
        indexesOfNewGroups: NSIndexSet,
        indexesOfModifiedGroups: NSIndexSet,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataCollector : metadataCollector, didCollectDateRangeMetadataGroups : metadataGroups, indexesOfNewGroups : indexesOfNewGroups, indexesOfModifiedGroups : indexesOfModifiedGroups)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemOutput(pub id);
impl std::ops::Deref for AVPlayerItemOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemOutput {}
impl AVPlayerItemOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemOutput").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemOutput {}
impl PNSObject for AVPlayerItemOutput {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemOutput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemOutput").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemOutput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemOutput")
        }
    }
}
impl IAVPlayerItemOutput for AVPlayerItemOutput {}
pub trait IAVPlayerItemOutput: Sized + std::ops::Deref {
    unsafe fn itemTimeForHostTime_(&self, hostTimeInSeconds: CFTimeInterval) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, itemTimeForHostTime : hostTimeInSeconds)
    }
    unsafe fn itemTimeForMachAbsoluteTime_(&self, machAbsoluteTime: i64) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, itemTimeForMachAbsoluteTime : machAbsoluteTime)
    }
    unsafe fn itemTimeForCVTimeStamp_(&self, timestamp: CVTimeStamp) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, itemTimeForCVTimeStamp : timestamp)
    }
    unsafe fn suppressesPlayerRendering(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, suppressesPlayerRendering)
    }
    unsafe fn setSuppressesPlayerRendering_(&self, suppressesPlayerRendering: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSuppressesPlayerRendering : suppressesPlayerRendering)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemVideoOutput(pub id);
impl std::ops::Deref for AVPlayerItemVideoOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemVideoOutput {}
impl AVPlayerItemVideoOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemVideoOutput").unwrap(), alloc) })
    }
}
impl IAVPlayerItemOutput for AVPlayerItemVideoOutput {}
impl From<AVPlayerItemVideoOutput> for AVPlayerItemOutput {
    fn from(child: AVPlayerItemVideoOutput) -> AVPlayerItemOutput {
        AVPlayerItemOutput(child.0)
    }
}
impl std::convert::TryFrom<AVPlayerItemOutput> for AVPlayerItemVideoOutput {
    type Error = &'static str;
    fn try_from(parent: AVPlayerItemOutput) -> Result<AVPlayerItemVideoOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemVideoOutput").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemVideoOutput(parent.0))
        } else {
            Err("This AVPlayerItemOutput cannot be downcasted to AVPlayerItemVideoOutput")
        }
    }
}
impl INSObject for AVPlayerItemVideoOutput {}
impl PNSObject for AVPlayerItemVideoOutput {}
impl IAVPlayerItemVideoOutput for AVPlayerItemVideoOutput {}
pub trait IAVPlayerItemVideoOutput: Sized + std::ops::Deref {
    unsafe fn initWithPixelBufferAttributes_(
        &self,
        pixelBufferAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPixelBufferAttributes : pixelBufferAttributes)
    }
    unsafe fn initWithOutputSettings_(&self, outputSettings: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithOutputSettings : outputSettings)
    }
    unsafe fn hasNewPixelBufferForItemTime_(&self, itemTime: CMTime) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasNewPixelBufferForItemTime : itemTime)
    }
    unsafe fn copyPixelBufferForItemTime_itemTimeForDisplay_(
        &self,
        itemTime: CMTime,
        outItemTimeForDisplay: *mut CMTime,
    ) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, copyPixelBufferForItemTime : itemTime, itemTimeForDisplay : outItemTimeForDisplay)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn requestNotificationOfMediaDataChangeWithAdvanceInterval_(
        &self,
        interval: NSTimeInterval,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, requestNotificationOfMediaDataChangeWithAdvanceInterval : interval)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
}
pub trait PAVPlayerItemOutputPullDelegate: Sized + std::ops::Deref {
    unsafe fn outputMediaDataWillChange_(&self, sender: AVPlayerItemOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, outputMediaDataWillChange : sender)
    }
    unsafe fn outputSequenceWasFlushed_(&self, output: AVPlayerItemOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, outputSequenceWasFlushed : output)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemLegibleOutput(pub id);
impl std::ops::Deref for AVPlayerItemLegibleOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemLegibleOutput {}
impl AVPlayerItemLegibleOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemLegibleOutput").unwrap(), alloc) })
    }
}
impl IAVPlayerItemOutput for AVPlayerItemLegibleOutput {}
impl std::convert::TryFrom<AVPlayerItemOutput> for AVPlayerItemLegibleOutput {
    type Error = &'static str;
    fn try_from(parent: AVPlayerItemOutput) -> Result<AVPlayerItemLegibleOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemLegibleOutput").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemLegibleOutput(parent.0))
        } else {
            Err("This AVPlayerItemOutput cannot be downcasted to AVPlayerItemLegibleOutput")
        }
    }
}
impl INSObject for AVPlayerItemLegibleOutput {}
impl PNSObject for AVPlayerItemLegibleOutput {}
impl IAVPlayerItemLegibleOutput for AVPlayerItemLegibleOutput {}
pub trait IAVPlayerItemLegibleOutput: Sized + std::ops::Deref {
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
    unsafe fn advanceIntervalForDelegateInvocation(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, advanceIntervalForDelegateInvocation)
    }
    unsafe fn setAdvanceIntervalForDelegateInvocation_(
        &self,
        advanceIntervalForDelegateInvocation: NSTimeInterval,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAdvanceIntervalForDelegateInvocation : advanceIntervalForDelegateInvocation)
    }
}
impl AVPlayerItemLegibleOutput_AVPlayerItemLegibleOutput_NativeRepresentation
    for AVPlayerItemLegibleOutput
{
}
pub trait AVPlayerItemLegibleOutput_AVPlayerItemLegibleOutput_NativeRepresentation:
    Sized + std::ops::Deref
{
    unsafe fn initWithMediaSubtypesForNativeRepresentation_(
        &self,
        subtypes: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithMediaSubtypesForNativeRepresentation : subtypes)
    }
}
impl AVPlayerItemLegibleOutput_AVPlayerItemLegibleOutput_TextStylingResolution
    for AVPlayerItemLegibleOutput
{
}
pub trait AVPlayerItemLegibleOutput_AVPlayerItemLegibleOutput_TextStylingResolution:
    Sized + std::ops::Deref
{
    unsafe fn textStylingResolution(&self) -> AVPlayerItemLegibleOutputTextStylingResolution
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, textStylingResolution)
    }
    unsafe fn setTextStylingResolution_(&self, textStylingResolution: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTextStylingResolution : textStylingResolution)
    }
}
pub type AVPlayerItemLegibleOutputTextStylingResolution = NSString;
pub trait PAVPlayerItemLegibleOutputPushDelegate: Sized + std::ops::Deref {
    unsafe fn legibleOutput_didOutputAttributedStrings_nativeSampleBuffers_forItemTime_(
        &self,
        output: AVPlayerItemLegibleOutput,
        strings: NSArray,
        nativeSamples: NSArray,
        itemTime: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, legibleOutput : output, didOutputAttributedStrings : strings, nativeSampleBuffers : nativeSamples, forItemTime : itemTime)
    }
}
pub trait PAVPlayerItemOutputPushDelegate: Sized + std::ops::Deref {
    unsafe fn outputSequenceWasFlushed_(&self, output: AVPlayerItemOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, outputSequenceWasFlushed : output)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemMetadataOutput(pub id);
impl std::ops::Deref for AVPlayerItemMetadataOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemMetadataOutput {}
impl AVPlayerItemMetadataOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemMetadataOutput").unwrap(), alloc) })
    }
}
impl IAVPlayerItemOutput for AVPlayerItemMetadataOutput {}
impl std::convert::TryFrom<AVPlayerItemOutput> for AVPlayerItemMetadataOutput {
    type Error = &'static str;
    fn try_from(parent: AVPlayerItemOutput) -> Result<AVPlayerItemMetadataOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemMetadataOutput").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemMetadataOutput(parent.0))
        } else {
            Err("This AVPlayerItemOutput cannot be downcasted to AVPlayerItemMetadataOutput")
        }
    }
}
impl INSObject for AVPlayerItemMetadataOutput {}
impl PNSObject for AVPlayerItemMetadataOutput {}
impl IAVPlayerItemMetadataOutput for AVPlayerItemMetadataOutput {}
pub trait IAVPlayerItemMetadataOutput: Sized + std::ops::Deref {
    unsafe fn initWithIdentifiers_(&self, identifiers: NSArray) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithIdentifiers : identifiers)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
    unsafe fn advanceIntervalForDelegateInvocation(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, advanceIntervalForDelegateInvocation)
    }
    unsafe fn setAdvanceIntervalForDelegateInvocation_(
        &self,
        advanceIntervalForDelegateInvocation: NSTimeInterval,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAdvanceIntervalForDelegateInvocation : advanceIntervalForDelegateInvocation)
    }
}
pub trait PAVPlayerItemMetadataOutputPushDelegate: Sized + std::ops::Deref {
    unsafe fn metadataOutput_didOutputTimedMetadataGroups_fromPlayerItemTrack_(
        &self,
        output: AVPlayerItemMetadataOutput,
        groups: NSArray,
        track: AVPlayerItemTrack,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataOutput : output, didOutputTimedMetadataGroups : groups, fromPlayerItemTrack : track)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemRenderedLegibleOutput(pub id);
impl std::ops::Deref for AVPlayerItemRenderedLegibleOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemRenderedLegibleOutput {}
impl AVPlayerItemRenderedLegibleOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemRenderedLegibleOutput").unwrap(), alloc) })
    }
}
impl IAVPlayerItemOutput for AVPlayerItemRenderedLegibleOutput {}
impl std::convert::TryFrom<AVPlayerItemOutput> for AVPlayerItemRenderedLegibleOutput {
    type Error = &'static str;
    fn try_from(
        parent: AVPlayerItemOutput,
    ) -> Result<AVPlayerItemRenderedLegibleOutput, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemRenderedLegibleOutput").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerItemRenderedLegibleOutput(parent.0))
        } else {
            Err("This AVPlayerItemOutput cannot be downcasted to AVPlayerItemRenderedLegibleOutput")
        }
    }
}
impl INSObject for AVPlayerItemRenderedLegibleOutput {}
impl PNSObject for AVPlayerItemRenderedLegibleOutput {}
impl IAVPlayerItemRenderedLegibleOutput for AVPlayerItemRenderedLegibleOutput {}
pub trait IAVPlayerItemRenderedLegibleOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithVideoDisplaySize_(&self, videoDisplaySize: CGSize) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithVideoDisplaySize : videoDisplaySize)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateQueue)
    }
    unsafe fn advanceIntervalForDelegateInvocation(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, advanceIntervalForDelegateInvocation)
    }
    unsafe fn setAdvanceIntervalForDelegateInvocation_(
        &self,
        advanceIntervalForDelegateInvocation: NSTimeInterval,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAdvanceIntervalForDelegateInvocation : advanceIntervalForDelegateInvocation)
    }
    unsafe fn videoDisplaySize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoDisplaySize)
    }
    unsafe fn setVideoDisplaySize_(&self, videoDisplaySize: CGSize)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoDisplaySize : videoDisplaySize)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemRenderedLegibleOutput").unwrap(), new)
    }
}
pub trait PAVPlayerItemRenderedLegibleOutputPushDelegate: Sized + std::ops::Deref {
    unsafe fn renderedLegibleOutput_didOutputRenderedCaptionImages_forItemTime_(
        &self,
        output: AVPlayerItemRenderedLegibleOutput,
        captionImages: NSArray,
        itemTime: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, renderedLegibleOutput : output, didOutputRenderedCaptionImages : captionImages, forItemTime : itemTime)
    }
}
pub type AVContentAuthorizationStatus = NSInteger;
impl AVPlayerItem_AVPlayerItemProtectedContent for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemProtectedContent: Sized + std::ops::Deref {
    unsafe fn requestContentAuthorizationAsynchronouslyWithTimeoutInterval_completionHandler_(
        &self,
        timeoutInterval: NSTimeInterval,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, requestContentAuthorizationAsynchronouslyWithTimeoutInterval : timeoutInterval, completionHandler : handler)
    }
    unsafe fn cancelContentAuthorizationRequest(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelContentAuthorizationRequest)
    }
    unsafe fn isAuthorizationRequiredForPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAuthorizationRequiredForPlayback)
    }
    unsafe fn isApplicationAuthorizedForPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isApplicationAuthorizedForPlayback)
    }
    unsafe fn isContentAuthorizedForPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isContentAuthorizedForPlayback)
    }
    unsafe fn contentAuthorizationRequestStatus(&self) -> AVContentAuthorizationStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentAuthorizationRequestStatus)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemTrack(pub id);
impl std::ops::Deref for AVPlayerItemTrack {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemTrack {}
impl AVPlayerItemTrack {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemTrack").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemTrack {}
impl PNSObject for AVPlayerItemTrack {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemTrack {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemTrack, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemTrack").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemTrack(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemTrack")
        }
    }
}
impl IAVPlayerItemTrack for AVPlayerItemTrack {}
pub trait IAVPlayerItemTrack: Sized + std::ops::Deref {
    unsafe fn assetTrack(&self) -> AVAssetTrack
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetTrack)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn currentVideoFrameRate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentVideoFrameRate)
    }
    unsafe fn videoFieldMode(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFieldMode)
    }
    unsafe fn setVideoFieldMode_(&self, videoFieldMode: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoFieldMode : videoFieldMode)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerLayer(pub id);
impl std::ops::Deref for AVPlayerLayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerLayer {}
impl AVPlayerLayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLayer").unwrap(), alloc) })
    }
}
impl ICALayer for AVPlayerLayer {}
impl PNSSecureCoding for AVPlayerLayer {}
impl PCAMediaTiming for AVPlayerLayer {}
impl std::convert::TryFrom<CALayer> for AVPlayerLayer {
    type Error = &'static str;
    fn try_from(parent: CALayer) -> Result<AVPlayerLayer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerLayer").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerLayer(parent.0))
        } else {
            Err("This CALayer cannot be downcasted to AVPlayerLayer")
        }
    }
}
impl INSObject for AVPlayerLayer {}
impl PNSObject for AVPlayerLayer {}
impl IAVPlayerLayer for AVPlayerLayer {}
pub trait IAVPlayerLayer: Sized + std::ops::Deref {
    unsafe fn copyDisplayedPixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copyDisplayedPixelBuffer)
    }
    unsafe fn player(&self) -> AVPlayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, player)
    }
    unsafe fn setPlayer_(&self, player: AVPlayer)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPlayer : player)
    }
    unsafe fn videoGravity(&self) -> AVLayerVideoGravity
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoGravity)
    }
    unsafe fn setVideoGravity_(&self, videoGravity: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoGravity : videoGravity)
    }
    unsafe fn isReadyForDisplay(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyForDisplay)
    }
    unsafe fn videoRect(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRect)
    }
    unsafe fn pixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelBufferAttributes)
    }
    unsafe fn setPixelBufferAttributes_(&self, pixelBufferAttributes: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPixelBufferAttributes : pixelBufferAttributes)
    }
    unsafe fn playerLayerWithPlayer_(player: AVPlayer) -> AVPlayerLayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLayer").unwrap(), playerLayerWithPlayer : player)
    }
}
pub type AVPlayerLooperStatus = NSInteger;
pub type AVPlayerLooperItemOrdering = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerLooper(pub id);
impl std::ops::Deref for AVPlayerLooper {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerLooper {}
impl AVPlayerLooper {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLooper").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerLooper {}
impl PNSObject for AVPlayerLooper {}
impl std::convert::TryFrom<NSObject> for AVPlayerLooper {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerLooper, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerLooper").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerLooper(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerLooper")
        }
    }
}
impl IAVPlayerLooper for AVPlayerLooper {}
pub trait IAVPlayerLooper: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithPlayer_templateItem_timeRange_(
        &self,
        player: AVQueuePlayer,
        itemToLoop: AVPlayerItem,
        loopRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPlayer : player, templateItem : itemToLoop, timeRange : loopRange)
    }
    unsafe fn initWithPlayer_templateItem_timeRange_existingItemsOrdering_(
        &self,
        player: AVQueuePlayer,
        itemToLoop: AVPlayerItem,
        loopRange: CMTimeRange,
        itemOrdering: AVPlayerLooperItemOrdering,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPlayer : player, templateItem : itemToLoop, timeRange : loopRange, existingItemsOrdering : itemOrdering)
    }
    unsafe fn disableLooping(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, disableLooping)
    }
    unsafe fn status(&self) -> AVPlayerLooperStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn loopCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loopCount)
    }
    unsafe fn loopingPlayerItems(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loopingPlayerItems)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLooper").unwrap(), new)
    }
    unsafe fn playerLooperWithPlayer_templateItem_timeRange_(
        player: AVQueuePlayer,
        itemToLoop: AVPlayerItem,
        loopRange: CMTimeRange,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLooper").unwrap(), playerLooperWithPlayer : player, templateItem : itemToLoop, timeRange : loopRange)
    }
    unsafe fn playerLooperWithPlayer_templateItem_(
        player: AVQueuePlayer,
        itemToLoop: AVPlayerItem,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerLooper").unwrap(), playerLooperWithPlayer : player, templateItem : itemToLoop)
    }
}
pub type AVPlayerInterstitialEventRestrictions = NSUInteger;
pub type AVPlayerInterstitialEventCue = NSString;
pub type AVPlayerInterstitialEventTimelineOccupancy = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerInterstitialEvent(pub id);
impl std::ops::Deref for AVPlayerInterstitialEvent {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerInterstitialEvent {}
impl AVPlayerInterstitialEvent {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), alloc) })
    }
}
impl PNSCopying for AVPlayerInterstitialEvent {}
impl INSObject for AVPlayerInterstitialEvent {}
impl PNSObject for AVPlayerInterstitialEvent {}
impl std::convert::TryFrom<NSObject> for AVPlayerInterstitialEvent {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerInterstitialEvent, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerInterstitialEvent(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerInterstitialEvent")
        }
    }
}
impl IAVPlayerInterstitialEvent for AVPlayerInterstitialEvent {}
pub trait IAVPlayerInterstitialEvent: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn primaryItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryItem)
    }
    unsafe fn identifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn time(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, time)
    }
    unsafe fn date(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, date)
    }
    unsafe fn templateItems(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, templateItems)
    }
    unsafe fn restrictions(&self) -> AVPlayerInterstitialEventRestrictions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, restrictions)
    }
    unsafe fn resumptionOffset(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resumptionOffset)
    }
    unsafe fn playoutLimit(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playoutLimit)
    }
    unsafe fn alignsStartWithPrimarySegmentBoundary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alignsStartWithPrimarySegmentBoundary)
    }
    unsafe fn alignsResumptionWithPrimarySegmentBoundary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alignsResumptionWithPrimarySegmentBoundary)
    }
    unsafe fn cue(&self) -> AVPlayerInterstitialEventCue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cue)
    }
    unsafe fn willPlayOnce(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, willPlayOnce)
    }
    unsafe fn userDefinedAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, userDefinedAttributes)
    }
    unsafe fn assetListResponse(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, assetListResponse)
    }
    unsafe fn timelineOccupancy(&self) -> AVPlayerInterstitialEventTimelineOccupancy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timelineOccupancy)
    }
    unsafe fn supplementsPrimaryContent(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supplementsPrimaryContent)
    }
    unsafe fn contentMayVary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentMayVary)
    }
    unsafe fn skipControlTimeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, skipControlTimeRange)
    }
    unsafe fn skipControlLocalizedLabelBundleKey(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, skipControlLocalizedLabelBundleKey)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), new)
    }
    unsafe fn interstitialEventWithPrimaryItem_identifier_time_templateItems_restrictions_resumptionOffset_playoutLimit_userDefinedAttributes_(
        primaryItem: AVPlayerItem,
        identifier: NSString,
        time: CMTime,
        templateItems: NSArray,
        restrictions: AVPlayerInterstitialEventRestrictions,
        resumptionOffset: CMTime,
        playoutLimit: CMTime,
        userDefinedAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), interstitialEventWithPrimaryItem : primaryItem, identifier : identifier, time : time, templateItems : templateItems, restrictions : restrictions, resumptionOffset : resumptionOffset, playoutLimit : playoutLimit, userDefinedAttributes : userDefinedAttributes)
    }
    unsafe fn interstitialEventWithPrimaryItem_identifier_date_templateItems_restrictions_resumptionOffset_playoutLimit_userDefinedAttributes_(
        primaryItem: AVPlayerItem,
        identifier: NSString,
        date: NSDate,
        templateItems: NSArray,
        restrictions: AVPlayerInterstitialEventRestrictions,
        resumptionOffset: CMTime,
        playoutLimit: CMTime,
        userDefinedAttributes: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), interstitialEventWithPrimaryItem : primaryItem, identifier : identifier, date : date, templateItems : templateItems, restrictions : restrictions, resumptionOffset : resumptionOffset, playoutLimit : playoutLimit, userDefinedAttributes : userDefinedAttributes)
    }
    unsafe fn interstitialEventWithPrimaryItem_time_(
        primaryItem: AVPlayerItem,
        time: CMTime,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), interstitialEventWithPrimaryItem : primaryItem, time : time)
    }
    unsafe fn interstitialEventWithPrimaryItem_date_(
        primaryItem: AVPlayerItem,
        date: NSDate,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEvent").unwrap(), interstitialEventWithPrimaryItem : primaryItem, date : date)
    }
}
pub type AVPlayerInterstitialEventAssetListResponseStatus = NSInteger;
pub type AVPlayerInterstitialEventSkippableEventState = NSInteger;
impl AVPlayerInterstitialEvent_MutableEvents for AVPlayerInterstitialEvent {}
pub trait AVPlayerInterstitialEvent_MutableEvents: Sized + std::ops::Deref {
    unsafe fn primaryItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryItem)
    }
    unsafe fn setPrimaryItem_(&self, primaryItem: AVPlayerItem)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPrimaryItem : primaryItem)
    }
    unsafe fn identifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, identifier)
    }
    unsafe fn setIdentifier_(&self, identifier: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setIdentifier : identifier)
    }
    unsafe fn time(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, time)
    }
    unsafe fn setTime_(&self, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTime : time)
    }
    unsafe fn date(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, date)
    }
    unsafe fn setDate_(&self, date: NSDate)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDate : date)
    }
    unsafe fn templateItems(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, templateItems)
    }
    unsafe fn setTemplateItems_(&self, templateItems: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTemplateItems : templateItems)
    }
    unsafe fn restrictions(&self) -> AVPlayerInterstitialEventRestrictions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, restrictions)
    }
    unsafe fn setRestrictions_(&self, restrictions: AVPlayerInterstitialEventRestrictions)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRestrictions : restrictions)
    }
    unsafe fn resumptionOffset(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resumptionOffset)
    }
    unsafe fn setResumptionOffset_(&self, resumptionOffset: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setResumptionOffset : resumptionOffset)
    }
    unsafe fn playoutLimit(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playoutLimit)
    }
    unsafe fn setPlayoutLimit_(&self, playoutLimit: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPlayoutLimit : playoutLimit)
    }
    unsafe fn alignsStartWithPrimarySegmentBoundary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alignsStartWithPrimarySegmentBoundary)
    }
    unsafe fn setAlignsStartWithPrimarySegmentBoundary_(
        &self,
        alignsStartWithPrimarySegmentBoundary: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlignsStartWithPrimarySegmentBoundary : alignsStartWithPrimarySegmentBoundary)
    }
    unsafe fn alignsResumptionWithPrimarySegmentBoundary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alignsResumptionWithPrimarySegmentBoundary)
    }
    unsafe fn setAlignsResumptionWithPrimarySegmentBoundary_(
        &self,
        alignsResumptionWithPrimarySegmentBoundary: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlignsResumptionWithPrimarySegmentBoundary : alignsResumptionWithPrimarySegmentBoundary)
    }
    unsafe fn cue(&self) -> AVPlayerInterstitialEventCue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cue)
    }
    unsafe fn setCue_(&self, cue: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCue : cue)
    }
    unsafe fn willPlayOnce(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, willPlayOnce)
    }
    unsafe fn setWillPlayOnce_(&self, willPlayOnce: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWillPlayOnce : willPlayOnce)
    }
    unsafe fn userDefinedAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, userDefinedAttributes)
    }
    unsafe fn setUserDefinedAttributes_(&self, userDefinedAttributes: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setUserDefinedAttributes : userDefinedAttributes)
    }
    unsafe fn timelineOccupancy(&self) -> AVPlayerInterstitialEventTimelineOccupancy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timelineOccupancy)
    }
    unsafe fn setTimelineOccupancy_(
        &self,
        timelineOccupancy: AVPlayerInterstitialEventTimelineOccupancy,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimelineOccupancy : timelineOccupancy)
    }
    unsafe fn supplementsPrimaryContent(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supplementsPrimaryContent)
    }
    unsafe fn setSupplementsPrimaryContent_(&self, supplementsPrimaryContent: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSupplementsPrimaryContent : supplementsPrimaryContent)
    }
    unsafe fn contentMayVary(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, contentMayVary)
    }
    unsafe fn setContentMayVary_(&self, contentMayVary: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setContentMayVary : contentMayVary)
    }
    unsafe fn plannedDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, plannedDuration)
    }
    unsafe fn setPlannedDuration_(&self, plannedDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPlannedDuration : plannedDuration)
    }
    unsafe fn skipControlTimeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, skipControlTimeRange)
    }
    unsafe fn setSkipControlTimeRange_(&self, skipControlTimeRange: CMTimeRange)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSkipControlTimeRange : skipControlTimeRange)
    }
    unsafe fn skipControlLocalizedLabelBundleKey(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, skipControlLocalizedLabelBundleKey)
    }
    unsafe fn setSkipControlLocalizedLabelBundleKey_(
        &self,
        skipControlLocalizedLabelBundleKey: NSString,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSkipControlLocalizedLabelBundleKey : skipControlLocalizedLabelBundleKey)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerInterstitialEventMonitor(pub id);
impl std::ops::Deref for AVPlayerInterstitialEventMonitor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerInterstitialEventMonitor {}
impl AVPlayerInterstitialEventMonitor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventMonitor").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerInterstitialEventMonitor {}
impl PNSObject for AVPlayerInterstitialEventMonitor {}
impl std::convert::TryFrom<NSObject> for AVPlayerInterstitialEventMonitor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerInterstitialEventMonitor, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventMonitor").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerInterstitialEventMonitor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerInterstitialEventMonitor")
        }
    }
}
impl IAVPlayerInterstitialEventMonitor for AVPlayerInterstitialEventMonitor {}
pub trait IAVPlayerInterstitialEventMonitor: Sized + std::ops::Deref {
    unsafe fn initWithPrimaryPlayer_(&self, primaryPlayer: AVPlayer) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPrimaryPlayer : primaryPlayer)
    }
    unsafe fn primaryPlayer(&self) -> AVPlayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryPlayer)
    }
    unsafe fn interstitialPlayer(&self) -> AVQueuePlayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, interstitialPlayer)
    }
    unsafe fn events(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, events)
    }
    unsafe fn currentEvent(&self) -> AVPlayerInterstitialEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentEvent)
    }
    unsafe fn currentEventSkippableState(&self) -> AVPlayerInterstitialEventSkippableEventState
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentEventSkippableState)
    }
    unsafe fn currentEventSkipControlLabel(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentEventSkipControlLabel)
    }
    unsafe fn interstitialEventMonitorWithPrimaryPlayer_(primaryPlayer: AVPlayer) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventMonitor").unwrap(), interstitialEventMonitorWithPrimaryPlayer : primaryPlayer)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerInterstitialEventController(pub id);
impl std::ops::Deref for AVPlayerInterstitialEventController {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerInterstitialEventController {}
impl AVPlayerInterstitialEventController {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventController").unwrap(), alloc) })
    }
}
impl IAVPlayerInterstitialEventMonitor for AVPlayerInterstitialEventController {}
impl From<AVPlayerInterstitialEventController> for AVPlayerInterstitialEventMonitor {
    fn from(child: AVPlayerInterstitialEventController) -> AVPlayerInterstitialEventMonitor {
        AVPlayerInterstitialEventMonitor(child.0)
    }
}
impl std::convert::TryFrom<AVPlayerInterstitialEventMonitor>
    for AVPlayerInterstitialEventController
{
    type Error = &'static str;
    fn try_from(
        parent: AVPlayerInterstitialEventMonitor,
    ) -> Result<AVPlayerInterstitialEventController, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventController").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerInterstitialEventController(parent.0))
        } else {
            Err ("This AVPlayerInterstitialEventMonitor cannot be downcasted to AVPlayerInterstitialEventController" ,)
        }
    }
}
impl INSObject for AVPlayerInterstitialEventController {}
impl PNSObject for AVPlayerInterstitialEventController {}
impl IAVPlayerInterstitialEventController for AVPlayerInterstitialEventController {}
pub trait IAVPlayerInterstitialEventController: Sized + std::ops::Deref {
    unsafe fn initWithPrimaryPlayer_(&self, primaryPlayer: AVPlayer) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPrimaryPlayer : primaryPlayer)
    }
    unsafe fn cancelCurrentEventWithResumptionOffset_(&self, resumptionOffset: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, cancelCurrentEventWithResumptionOffset : resumptionOffset)
    }
    unsafe fn skipCurrentEvent(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, skipCurrentEvent)
    }
    unsafe fn events(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, events)
    }
    unsafe fn setEvents_(&self, events: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEvents : events)
    }
    unsafe fn localizedStringsBundle(&self) -> NSBundle
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedStringsBundle)
    }
    unsafe fn setLocalizedStringsBundle_(&self, localizedStringsBundle: NSBundle)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLocalizedStringsBundle : localizedStringsBundle)
    }
    unsafe fn localizedStringsTableName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedStringsTableName)
    }
    unsafe fn setLocalizedStringsTableName_(&self, localizedStringsTableName: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLocalizedStringsTableName : localizedStringsTableName)
    }
    unsafe fn interstitialEventControllerWithPrimaryPlayer_(primaryPlayer: AVPlayer) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerInterstitialEventController").unwrap(), interstitialEventControllerWithPrimaryPlayer : primaryPlayer)
    }
}
impl AVPlayer_AVPlayerInterstitialSupport for AVPlayer {}
pub trait AVPlayer_AVPlayerInterstitialSupport: Sized + std::ops::Deref {}
impl AVPlayerItem_AVPlayerInterstitialSupport for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerInterstitialSupport: Sized + std::ops::Deref {
    unsafe fn automaticallyHandlesInterstitialEvents(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyHandlesInterstitialEvents)
    }
    unsafe fn setAutomaticallyHandlesInterstitialEvents_(
        &self,
        automaticallyHandlesInterstitialEvents: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyHandlesInterstitialEvents : automaticallyHandlesInterstitialEvents)
    }
    unsafe fn templatePlayerItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, templatePlayerItem)
    }
}
pub type AVPlayerItemSegmentType = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemSegment(pub id);
impl std::ops::Deref for AVPlayerItemSegment {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemSegment {}
impl AVPlayerItemSegment {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemSegment").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemSegment {}
impl PNSObject for AVPlayerItemSegment {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemSegment {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemSegment, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemSegment").unwrap()) };
        if is_kind_of {
            Ok(AVPlayerItemSegment(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemSegment")
        }
    }
}
impl IAVPlayerItemSegment for AVPlayerItemSegment {}
pub trait IAVPlayerItemSegment: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn segmentType(&self) -> AVPlayerItemSegmentType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segmentType)
    }
    unsafe fn timeMapping(&self) -> CMTimeMapping
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timeMapping)
    }
    unsafe fn loadedTimeRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, loadedTimeRanges)
    }
    unsafe fn startDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startDate)
    }
    unsafe fn interstitialEvent(&self) -> AVPlayerInterstitialEvent
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, interstitialEvent)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemSegment").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemIntegratedTimelineSnapshot(pub id);
impl std::ops::Deref for AVPlayerItemIntegratedTimelineSnapshot {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemIntegratedTimelineSnapshot {}
impl AVPlayerItemIntegratedTimelineSnapshot {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimelineSnapshot").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemIntegratedTimelineSnapshot {}
impl PNSObject for AVPlayerItemIntegratedTimelineSnapshot {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemIntegratedTimelineSnapshot {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemIntegratedTimelineSnapshot, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimelineSnapshot").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerItemIntegratedTimelineSnapshot(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemIntegratedTimelineSnapshot")
        }
    }
}
impl IAVPlayerItemIntegratedTimelineSnapshot for AVPlayerItemIntegratedTimelineSnapshot {}
pub trait IAVPlayerItemIntegratedTimelineSnapshot: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn mapTime_toSegment_atSegmentOffset_(
        &self,
        time: CMTime,
        timeSegmentOut: *mut AVPlayerItemSegment,
        segmentOffsetOut: *mut CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, mapTime : time, toSegment : timeSegmentOut, atSegmentOffset : segmentOffsetOut)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn currentSegment(&self) -> AVPlayerItemSegment
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSegment)
    }
    unsafe fn segments(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, segments)
    }
    unsafe fn currentTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentTime)
    }
    unsafe fn currentDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentDate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimelineSnapshot").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPlayerItemIntegratedTimeline(pub id);
impl std::ops::Deref for AVPlayerItemIntegratedTimeline {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPlayerItemIntegratedTimeline {}
impl AVPlayerItemIntegratedTimeline {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimeline").unwrap(), alloc) })
    }
}
impl INSObject for AVPlayerItemIntegratedTimeline {}
impl PNSObject for AVPlayerItemIntegratedTimeline {}
impl std::convert::TryFrom<NSObject> for AVPlayerItemIntegratedTimeline {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPlayerItemIntegratedTimeline, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimeline").unwrap())
        };
        if is_kind_of {
            Ok(AVPlayerItemIntegratedTimeline(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPlayerItemIntegratedTimeline")
        }
    }
}
impl IAVPlayerItemIntegratedTimeline for AVPlayerItemIntegratedTimeline {}
pub trait IAVPlayerItemIntegratedTimeline: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn currentSnapshot(&self) -> AVPlayerItemIntegratedTimelineSnapshot
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSnapshot)
    }
    unsafe fn currentTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentTime)
    }
    unsafe fn currentDate(&self) -> NSDate
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentDate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPlayerItemIntegratedTimeline").unwrap(), new)
    }
}
impl AVPlayerItemIntegratedTimeline_AVPlayerItemIntegratedTimelineControl
    for AVPlayerItemIntegratedTimeline
{
}
pub trait AVPlayerItemIntegratedTimeline_AVPlayerItemIntegratedTimelineControl:
    Sized + std::ops::Deref
{
    unsafe fn seekToTime_toleranceBefore_toleranceAfter_completionHandler_(
        &self,
        time: CMTime,
        toleranceBefore: CMTime,
        toleranceAfter: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToTime : time, toleranceBefore : toleranceBefore, toleranceAfter : toleranceAfter, completionHandler : completionHandler)
    }
    unsafe fn seekToDate_completionHandler_(
        &self,
        date: NSDate,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, seekToDate : date, completionHandler : completionHandler)
    }
}
pub trait PAVPlayerItemIntegratedTimelineObserver: Sized + std::ops::Deref {}
impl AVPlayerItemIntegratedTimeline_AVPlayerItemIntegratedTimelineObserver
    for AVPlayerItemIntegratedTimeline
{
}
pub trait AVPlayerItemIntegratedTimeline_AVPlayerItemIntegratedTimelineObserver:
    Sized + std::ops::Deref
{
    unsafe fn addPeriodicTimeObserverForInterval_queue_usingBlock_(
        &self,
        interval: CMTime,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addPeriodicTimeObserverForInterval : interval, queue : queue, usingBlock : block)
    }
    unsafe fn addBoundaryTimeObserverForSegment_offsetsIntoSegment_queue_usingBlock_(
        &self,
        segment: AVPlayerItemSegment,
        offsetsIntoSegment: NSArray,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addBoundaryTimeObserverForSegment : segment, offsetsIntoSegment : offsetsIntoSegment, queue : queue, usingBlock : block)
    }
    unsafe fn removeTimeObserver_(&self, observer: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeObserver : observer)
    }
}
impl AVPlayerItem_AVPlayerItemIntegratedTimelineSupport for AVPlayerItem {}
pub trait AVPlayerItem_AVPlayerItemIntegratedTimelineSupport: Sized + std::ops::Deref {
    unsafe fn integratedTimeline(&self) -> AVPlayerItemIntegratedTimeline
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, integratedTimeline)
    }
}
pub type AVQueuedSampleBufferRenderingStatus = NSInteger;
pub trait PAVQueuedSampleBufferRendering: Sized + std::ops::Deref {
    unsafe fn enqueueSampleBuffer_(&self, sampleBuffer: CMSampleBufferRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, enqueueSampleBuffer : sampleBuffer)
    }
    unsafe fn flush(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flush)
    }
    unsafe fn requestMediaDataWhenReadyOnQueue_usingBlock_(
        &self,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, requestMediaDataWhenReadyOnQueue : queue, usingBlock : block)
    }
    unsafe fn stopRequestingMediaData(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopRequestingMediaData)
    }
    unsafe fn timebase(&self) -> CMTimebaseRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timebase)
    }
    unsafe fn isReadyForMoreMediaData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyForMoreMediaData)
    }
    unsafe fn hasSufficientMediaDataForReliablePlaybackStart(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasSufficientMediaDataForReliablePlaybackStart)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVRenderedCaptionImage(pub id);
impl std::ops::Deref for AVRenderedCaptionImage {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVRenderedCaptionImage {}
impl AVRenderedCaptionImage {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVRenderedCaptionImage").unwrap(), alloc) })
    }
}
impl INSObject for AVRenderedCaptionImage {}
impl PNSObject for AVRenderedCaptionImage {}
impl std::convert::TryFrom<NSObject> for AVRenderedCaptionImage {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVRenderedCaptionImage, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVRenderedCaptionImage").unwrap()) };
        if is_kind_of {
            Ok(AVRenderedCaptionImage(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVRenderedCaptionImage")
        }
    }
}
impl IAVRenderedCaptionImage for AVRenderedCaptionImage {}
pub trait IAVRenderedCaptionImage: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn pixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelBuffer)
    }
    unsafe fn position(&self) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, position)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVRenderedCaptionImage").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVRouteDetector(pub id);
impl std::ops::Deref for AVRouteDetector {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVRouteDetector {}
impl AVRouteDetector {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVRouteDetector").unwrap(), alloc) })
    }
}
impl INSObject for AVRouteDetector {}
impl PNSObject for AVRouteDetector {}
impl std::convert::TryFrom<NSObject> for AVRouteDetector {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVRouteDetector, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVRouteDetector").unwrap()) };
        if is_kind_of {
            Ok(AVRouteDetector(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVRouteDetector")
        }
    }
}
impl IAVRouteDetector for AVRouteDetector {}
pub trait IAVRouteDetector: Sized + std::ops::Deref {
    unsafe fn isRouteDetectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRouteDetectionEnabled)
    }
    unsafe fn setRouteDetectionEnabled_(&self, routeDetectionEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRouteDetectionEnabled : routeDetectionEnabled)
    }
    unsafe fn multipleRoutesDetected(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, multipleRoutesDetected)
    }
    unsafe fn detectsCustomRoutes(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, detectsCustomRoutes)
    }
    unsafe fn setDetectsCustomRoutes_(&self, detectsCustomRoutes: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDetectsCustomRoutes : detectsCustomRoutes)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferAudioRenderer(pub id);
impl std::ops::Deref for AVSampleBufferAudioRenderer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferAudioRenderer {}
impl AVSampleBufferAudioRenderer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferAudioRenderer").unwrap(), alloc) })
    }
}
impl PAVQueuedSampleBufferRendering for AVSampleBufferAudioRenderer {}
impl INSObject for AVSampleBufferAudioRenderer {}
impl PNSObject for AVSampleBufferAudioRenderer {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferAudioRenderer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferAudioRenderer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferAudioRenderer").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferAudioRenderer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferAudioRenderer")
        }
    }
}
impl IAVSampleBufferAudioRenderer for AVSampleBufferAudioRenderer {}
pub trait IAVSampleBufferAudioRenderer: Sized + std::ops::Deref {
    unsafe fn status(&self) -> AVQueuedSampleBufferRenderingStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn audioOutputDeviceUniqueID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioOutputDeviceUniqueID)
    }
    unsafe fn setAudioOutputDeviceUniqueID_(&self, audioOutputDeviceUniqueID: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioOutputDeviceUniqueID : audioOutputDeviceUniqueID)
    }
    unsafe fn audioTimePitchAlgorithm(&self) -> AVAudioTimePitchAlgorithm
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioTimePitchAlgorithm)
    }
    unsafe fn setAudioTimePitchAlgorithm_(&self, audioTimePitchAlgorithm: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioTimePitchAlgorithm : audioTimePitchAlgorithm)
    }
    unsafe fn allowedAudioSpatializationFormats(&self) -> AVAudioSpatializationFormats
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, allowedAudioSpatializationFormats)
    }
    unsafe fn setAllowedAudioSpatializationFormats_(
        &self,
        allowedAudioSpatializationFormats: AVAudioSpatializationFormats,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAllowedAudioSpatializationFormats : allowedAudioSpatializationFormats)
    }
}
impl AVSampleBufferAudioRenderer_AVSampleBufferAudioRendererVolumeControl
    for AVSampleBufferAudioRenderer
{
}
pub trait AVSampleBufferAudioRenderer_AVSampleBufferAudioRendererVolumeControl:
    Sized + std::ops::Deref
{
    unsafe fn volume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, volume)
    }
    unsafe fn setVolume_(&self, volume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolume : volume)
    }
    unsafe fn isMuted(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMuted)
    }
    unsafe fn setMuted_(&self, muted: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMuted : muted)
    }
}
impl AVSampleBufferAudioRenderer_AVSampleBufferAudioRendererQueueManagement
    for AVSampleBufferAudioRenderer
{
}
pub trait AVSampleBufferAudioRenderer_AVSampleBufferAudioRendererQueueManagement:
    Sized + std::ops::Deref
{
    unsafe fn flushFromSourceTime_completionHandler_(
        &self,
        time: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, flushFromSourceTime : time, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferDisplayLayer(pub id);
impl std::ops::Deref for AVSampleBufferDisplayLayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferDisplayLayer {}
impl AVSampleBufferDisplayLayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferDisplayLayer").unwrap(), alloc) })
    }
}
impl ICALayer for AVSampleBufferDisplayLayer {}
impl PNSSecureCoding for AVSampleBufferDisplayLayer {}
impl PCAMediaTiming for AVSampleBufferDisplayLayer {}
impl std::convert::TryFrom<CALayer> for AVSampleBufferDisplayLayer {
    type Error = &'static str;
    fn try_from(parent: CALayer) -> Result<AVSampleBufferDisplayLayer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferDisplayLayer").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferDisplayLayer(parent.0))
        } else {
            Err("This CALayer cannot be downcasted to AVSampleBufferDisplayLayer")
        }
    }
}
impl INSObject for AVSampleBufferDisplayLayer {}
impl PNSObject for AVSampleBufferDisplayLayer {}
impl IAVSampleBufferDisplayLayer for AVSampleBufferDisplayLayer {}
pub trait IAVSampleBufferDisplayLayer: Sized + std::ops::Deref {
    unsafe fn controlTimebase(&self) -> CMTimebaseRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, controlTimebase)
    }
    unsafe fn setControlTimebase_(&self, controlTimebase: CMTimebaseRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setControlTimebase : controlTimebase)
    }
    unsafe fn videoGravity(&self) -> AVLayerVideoGravity
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoGravity)
    }
    unsafe fn setVideoGravity_(&self, videoGravity: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoGravity : videoGravity)
    }
    unsafe fn isReadyForDisplay(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyForDisplay)
    }
}
impl AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerQueueManagement
    for AVSampleBufferDisplayLayer
{
}
pub trait AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerQueueManagement:
    Sized + std::ops::Deref
{
    unsafe fn enqueueSampleBuffer_(&self, sampleBuffer: CMSampleBufferRef)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, enqueueSampleBuffer : sampleBuffer)
    }
    unsafe fn flush(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flush)
    }
    unsafe fn flushAndRemoveImage(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flushAndRemoveImage)
    }
    unsafe fn requestMediaDataWhenReadyOnQueue_usingBlock_(
        &self,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, requestMediaDataWhenReadyOnQueue : queue, usingBlock : block)
    }
    unsafe fn stopRequestingMediaData(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopRequestingMediaData)
    }
    unsafe fn timebase(&self) -> CMTimebaseRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timebase)
    }
    unsafe fn status(&self) -> AVQueuedSampleBufferRenderingStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn requiresFlushToResumeDecoding(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiresFlushToResumeDecoding)
    }
    unsafe fn isReadyForMoreMediaData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isReadyForMoreMediaData)
    }
    unsafe fn hasSufficientMediaDataForReliablePlaybackStart(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasSufficientMediaDataForReliablePlaybackStart)
    }
}
impl AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerImageProtection
    for AVSampleBufferDisplayLayer
{
}
pub trait AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerImageProtection:
    Sized + std::ops::Deref
{
    unsafe fn preventsCapture(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preventsCapture)
    }
    unsafe fn setPreventsCapture_(&self, preventsCapture: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreventsCapture : preventsCapture)
    }
}
impl AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerVideoDisplaySleepPrevention
    for AVSampleBufferDisplayLayer
{
}
pub trait AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerVideoDisplaySleepPrevention:
    Sized + std::ops::Deref
{
    unsafe fn preventsDisplaySleepDuringVideoPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preventsDisplaySleepDuringVideoPlayback)
    }
    unsafe fn setPreventsDisplaySleepDuringVideoPlayback_(
        &self,
        preventsDisplaySleepDuringVideoPlayback: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreventsDisplaySleepDuringVideoPlayback : preventsDisplaySleepDuringVideoPlayback)
    }
}
impl AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerAutomaticBackgroundPrevention
    for AVSampleBufferDisplayLayer
{
}
pub trait AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerAutomaticBackgroundPrevention:
    Sized + std::ops::Deref
{
    unsafe fn preventsAutomaticBackgroundingDuringVideoPlayback(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preventsAutomaticBackgroundingDuringVideoPlayback)
    }
    unsafe fn setPreventsAutomaticBackgroundingDuringVideoPlayback_(
        &self,
        preventsAutomaticBackgroundingDuringVideoPlayback: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreventsAutomaticBackgroundingDuringVideoPlayback : preventsAutomaticBackgroundingDuringVideoPlayback)
    }
}
impl AVSampleBufferDisplayLayer_ProtectedContent for AVSampleBufferDisplayLayer {}
pub trait AVSampleBufferDisplayLayer_ProtectedContent: Sized + std::ops::Deref {
    unsafe fn outputObscuredDueToInsufficientExternalProtection(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputObscuredDueToInsufficientExternalProtection)
    }
}
impl AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerRenderer for AVSampleBufferDisplayLayer {}
pub trait AVSampleBufferDisplayLayer_AVSampleBufferDisplayLayerRenderer:
    Sized + std::ops::Deref
{
    unsafe fn sampleBufferRenderer(&self) -> AVSampleBufferVideoRenderer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferRenderer)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferRenderSynchronizer(pub id);
impl std::ops::Deref for AVSampleBufferRenderSynchronizer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferRenderSynchronizer {}
impl AVSampleBufferRenderSynchronizer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferRenderSynchronizer").unwrap(), alloc) })
    }
}
impl INSObject for AVSampleBufferRenderSynchronizer {}
impl PNSObject for AVSampleBufferRenderSynchronizer {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferRenderSynchronizer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferRenderSynchronizer, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferRenderSynchronizer").unwrap())
        };
        if is_kind_of {
            Ok(AVSampleBufferRenderSynchronizer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferRenderSynchronizer")
        }
    }
}
impl IAVSampleBufferRenderSynchronizer for AVSampleBufferRenderSynchronizer {}
pub trait IAVSampleBufferRenderSynchronizer: Sized + std::ops::Deref {
    unsafe fn currentTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentTime)
    }
    unsafe fn setRate_time_(&self, rate: f32, time: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRate : rate, time : time)
    }
    unsafe fn setRate_time_atHostTime_(&self, rate: f32, time: CMTime, hostTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRate : rate, time : time, atHostTime : hostTime)
    }
    unsafe fn timebase(&self) -> CMTimebaseRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timebase)
    }
    unsafe fn rate(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rate)
    }
    unsafe fn setRate_(&self, rate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRate : rate)
    }
    unsafe fn delaysRateChangeUntilHasSufficientMediaData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delaysRateChangeUntilHasSufficientMediaData)
    }
    unsafe fn setDelaysRateChangeUntilHasSufficientMediaData_(
        &self,
        delaysRateChangeUntilHasSufficientMediaData: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelaysRateChangeUntilHasSufficientMediaData : delaysRateChangeUntilHasSufficientMediaData)
    }
}
impl AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerRendererManagement
    for AVSampleBufferRenderSynchronizer
{
}
pub trait AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerRendererManagement:
    Sized + std::ops::Deref
{
    unsafe fn addRenderer_(&self, renderer: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addRenderer : renderer)
    }
    unsafe fn removeRenderer_atTime_completionHandler_(
        &self,
        renderer: *mut u64,
        time: CMTime,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeRenderer : renderer, atTime : time, completionHandler : completionHandler)
    }
    unsafe fn renderers(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, renderers)
    }
}
impl AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerTimeObservation
    for AVSampleBufferRenderSynchronizer
{
}
pub trait AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerTimeObservation:
    Sized + std::ops::Deref
{
    unsafe fn addPeriodicTimeObserverForInterval_queue_usingBlock_(
        &self,
        interval: CMTime,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addPeriodicTimeObserverForInterval : interval, queue : queue, usingBlock : block)
    }
    unsafe fn addBoundaryTimeObserverForTimes_queue_usingBlock_(
        &self,
        times: NSArray,
        queue: NSObject,
        block: *mut ::std::os::raw::c_void,
    ) -> id
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addBoundaryTimeObserverForTimes : times, queue : queue, usingBlock : block)
    }
    unsafe fn removeTimeObserver_(&self, observer: id)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeTimeObserver : observer)
    }
}
impl AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerSpatialAudioExperience
    for AVSampleBufferRenderSynchronizer
{
}
pub trait AVSampleBufferRenderSynchronizer_AVSampleBufferRenderSynchronizerSpatialAudioExperience:
    Sized + std::ops::Deref
{
    unsafe fn intendedSpatialAudioExperience(&self) -> CASpatialAudioExperience
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, intendedSpatialAudioExperience)
    }
    unsafe fn setIntendedSpatialAudioExperience_(
        &self,
        intendedSpatialAudioExperience: CASpatialAudioExperience,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setIntendedSpatialAudioExperience : intendedSpatialAudioExperience)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursor(pub id);
impl std::ops::Deref for AVSampleCursor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleCursor {}
impl AVSampleCursor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleCursor").unwrap(), alloc) })
    }
}
impl PNSCopying for AVSampleCursor {}
impl INSObject for AVSampleCursor {}
impl PNSObject for AVSampleCursor {}
impl std::convert::TryFrom<NSObject> for AVSampleCursor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleCursor, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleCursor").unwrap()) };
        if is_kind_of {
            Ok(AVSampleCursor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleCursor")
        }
    }
}
impl IAVSampleCursor for AVSampleCursor {}
pub trait IAVSampleCursor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn stepInDecodeOrderByCount_(&self, stepCount: i64) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stepInDecodeOrderByCount : stepCount)
    }
    unsafe fn stepInPresentationOrderByCount_(&self, stepCount: i64) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stepInPresentationOrderByCount : stepCount)
    }
    unsafe fn stepByDecodeTime_wasPinned_(
        &self,
        deltaDecodeTime: CMTime,
        outWasPinned: *mut BOOL,
    ) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stepByDecodeTime : deltaDecodeTime, wasPinned : outWasPinned)
    }
    unsafe fn stepByPresentationTime_wasPinned_(
        &self,
        deltaPresentationTime: CMTime,
        outWasPinned: *mut BOOL,
    ) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stepByPresentationTime : deltaPresentationTime, wasPinned : outWasPinned)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleCursor").unwrap(), new)
    }
}
impl AVSampleCursor_AVSampleCursorTemporalPosition for AVSampleCursor {}
pub trait AVSampleCursor_AVSampleCursorTemporalPosition: Sized + std::ops::Deref {
    unsafe fn comparePositionInDecodeOrderWithPositionOfCursor_(
        &self,
        cursor: AVSampleCursor,
    ) -> NSComparisonResult
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, comparePositionInDecodeOrderWithPositionOfCursor : cursor)
    }
    unsafe fn samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor_(
        &self,
        cursor: AVSampleCursor,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor : cursor)
    }
    unsafe fn samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor_(
        &self,
        cursor: AVSampleCursor,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor : cursor)
    }
    unsafe fn presentationTimeStamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, presentationTimeStamp)
    }
    unsafe fn decodeTimeStamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, decodeTimeStamp)
    }
}
impl AVSampleCursor_AVSampleCursorCurrentSampleInfo for AVSampleCursor {}
pub trait AVSampleCursor_AVSampleCursorCurrentSampleInfo: Sized + std::ops::Deref {
    unsafe fn copyCurrentSampleFormatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copyCurrentSampleFormatDescription)
    }
    unsafe fn currentSampleDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleDuration)
    }
    unsafe fn currentSampleSyncInfo(&self) -> AVSampleCursorSyncInfo
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleSyncInfo)
    }
    unsafe fn currentSampleDependencyInfo(&self) -> AVSampleCursorDependencyInfo
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleDependencyInfo)
    }
    unsafe fn currentSampleDependencyAttachments(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleDependencyAttachments)
    }
    unsafe fn currentSampleAudioDependencyInfo(&self) -> AVSampleCursorAudioDependencyInfo
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleAudioDependencyInfo)
    }
    unsafe fn samplesRequiredForDecoderRefresh(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, samplesRequiredForDecoderRefresh)
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursorSyncInfo {
    pub sampleIsFullSync: BOOL,
    pub sampleIsPartialSync: BOOL,
    pub sampleIsDroppable: BOOL,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursorDependencyInfo {
    pub sampleIndicatesWhetherItHasDependentSamples: BOOL,
    pub sampleHasDependentSamples: BOOL,
    pub sampleIndicatesWhetherItDependsOnOthers: BOOL,
    pub sampleDependsOnOthers: BOOL,
    pub sampleIndicatesWhetherItHasRedundantCoding: BOOL,
    pub sampleHasRedundantCoding: BOOL,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursorAudioDependencyInfo {
    pub audioSampleIsIndependentlyDecodable: BOOL,
    pub audioSamplePacketRefreshCount: NSInteger,
}
impl AVSampleCursor_AVSampleCursorSampleStorageInfo for AVSampleCursor {}
pub trait AVSampleCursor_AVSampleCursorSampleStorageInfo: Sized + std::ops::Deref {
    unsafe fn currentChunkStorageURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentChunkStorageURL)
    }
    unsafe fn currentChunkStorageRange(&self) -> AVSampleCursorStorageRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentChunkStorageRange)
    }
    unsafe fn currentChunkInfo(&self) -> AVSampleCursorChunkInfo
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentChunkInfo)
    }
    unsafe fn currentSampleIndexInChunk(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleIndexInChunk)
    }
    unsafe fn currentSampleStorageRange(&self) -> AVSampleCursorStorageRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSampleStorageRange)
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursorStorageRange {
    pub offset: i64,
    pub length: i64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleCursorChunkInfo {
    pub chunkSampleCount: i64,
    pub chunkHasUniformSampleSizes: BOOL,
    pub chunkHasUniformSampleDurations: BOOL,
    pub chunkHasUniformFormatDescriptions: BOOL,
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferGenerator(pub id);
impl std::ops::Deref for AVSampleBufferGenerator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferGenerator {}
impl AVSampleBufferGenerator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferGenerator").unwrap(), alloc) })
    }
}
impl INSObject for AVSampleBufferGenerator {}
impl PNSObject for AVSampleBufferGenerator {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferGenerator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferGenerator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferGenerator").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferGenerator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferGenerator")
        }
    }
}
impl IAVSampleBufferGenerator for AVSampleBufferGenerator {}
pub trait IAVSampleBufferGenerator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithAsset_timebase_(
        &self,
        asset: AVAsset,
        timebase: CMTimebaseRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithAsset : asset, timebase : timebase)
    }
    unsafe fn createSampleBufferForRequest_error_(
        &self,
        request: AVSampleBufferRequest,
        outError: *mut NSError,
    ) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, createSampleBufferForRequest : request, error : outError)
    }
    unsafe fn createSampleBufferForRequest_(
        &self,
        request: AVSampleBufferRequest,
    ) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, createSampleBufferForRequest : request)
    }
    unsafe fn makeBatch(&self) -> AVSampleBufferGeneratorBatch
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, makeBatch)
    }
    unsafe fn createSampleBufferForRequest_addingToBatch_error_(
        &self,
        request: AVSampleBufferRequest,
        batch: AVSampleBufferGeneratorBatch,
        outError: *mut NSError,
    ) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, createSampleBufferForRequest : request, addingToBatch : batch, error : outError)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferGenerator").unwrap(), new)
    }
    unsafe fn notifyOfDataReadyForSampleBuffer_completionHandler_(
        sbuf: CMSampleBufferRef,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferGenerator").unwrap(), notifyOfDataReadyForSampleBuffer : sbuf, completionHandler : completionHandler)
    }
}
pub type AVSampleBufferRequestDirection = NSInteger;
pub type AVSampleBufferRequestMode = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferRequest(pub id);
impl std::ops::Deref for AVSampleBufferRequest {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferRequest {}
impl AVSampleBufferRequest {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferRequest").unwrap(), alloc) })
    }
}
impl INSObject for AVSampleBufferRequest {}
impl PNSObject for AVSampleBufferRequest {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferRequest {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferRequest, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferRequest").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferRequest(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferRequest")
        }
    }
}
impl IAVSampleBufferRequest for AVSampleBufferRequest {}
pub trait IAVSampleBufferRequest: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithStartCursor_(&self, startCursor: AVSampleCursor) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithStartCursor : startCursor)
    }
    unsafe fn startCursor(&self) -> AVSampleCursor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startCursor)
    }
    unsafe fn direction(&self) -> AVSampleBufferRequestDirection
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, direction)
    }
    unsafe fn setDirection_(&self, direction: AVSampleBufferRequestDirection)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDirection : direction)
    }
    unsafe fn limitCursor(&self) -> AVSampleCursor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, limitCursor)
    }
    unsafe fn setLimitCursor_(&self, limitCursor: AVSampleCursor)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLimitCursor : limitCursor)
    }
    unsafe fn preferredMinSampleCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredMinSampleCount)
    }
    unsafe fn setPreferredMinSampleCount_(&self, preferredMinSampleCount: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredMinSampleCount : preferredMinSampleCount)
    }
    unsafe fn maxSampleCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxSampleCount)
    }
    unsafe fn setMaxSampleCount_(&self, maxSampleCount: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxSampleCount : maxSampleCount)
    }
    unsafe fn mode(&self) -> AVSampleBufferRequestMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mode)
    }
    unsafe fn setMode_(&self, mode: AVSampleBufferRequestMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMode : mode)
    }
    unsafe fn overrideTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, overrideTime)
    }
    unsafe fn setOverrideTime_(&self, overrideTime: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOverrideTime : overrideTime)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferRequest").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferGeneratorBatch(pub id);
impl std::ops::Deref for AVSampleBufferGeneratorBatch {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferGeneratorBatch {}
impl AVSampleBufferGeneratorBatch {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferGeneratorBatch").unwrap(), alloc) })
    }
}
impl INSObject for AVSampleBufferGeneratorBatch {}
impl PNSObject for AVSampleBufferGeneratorBatch {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferGeneratorBatch {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferGeneratorBatch, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferGeneratorBatch").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferGeneratorBatch(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferGeneratorBatch")
        }
    }
}
impl IAVSampleBufferGeneratorBatch for AVSampleBufferGeneratorBatch {}
pub trait IAVSampleBufferGeneratorBatch: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn makeDataReadyWithCompletionHandler_(
        &self,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, makeDataReadyWithCompletionHandler : completionHandler)
    }
    unsafe fn cancel(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancel)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferGeneratorBatch").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSampleBufferVideoRenderer(pub id);
impl std::ops::Deref for AVSampleBufferVideoRenderer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSampleBufferVideoRenderer {}
impl AVSampleBufferVideoRenderer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSampleBufferVideoRenderer").unwrap(), alloc) })
    }
}
impl PAVQueuedSampleBufferRendering for AVSampleBufferVideoRenderer {}
impl INSObject for AVSampleBufferVideoRenderer {}
impl PNSObject for AVSampleBufferVideoRenderer {}
impl std::convert::TryFrom<NSObject> for AVSampleBufferVideoRenderer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSampleBufferVideoRenderer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSampleBufferVideoRenderer").unwrap()) };
        if is_kind_of {
            Ok(AVSampleBufferVideoRenderer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSampleBufferVideoRenderer")
        }
    }
}
impl IAVSampleBufferVideoRenderer for AVSampleBufferVideoRenderer {}
pub trait IAVSampleBufferVideoRenderer: Sized + std::ops::Deref {
    unsafe fn flushWithRemovalOfDisplayedImage_completionHandler_(
        &self,
        removeDisplayedImage: BOOL,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, flushWithRemovalOfDisplayedImage : removeDisplayedImage, completionHandler : handler)
    }
    unsafe fn status(&self) -> AVQueuedSampleBufferRenderingStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn error(&self) -> NSError
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, error)
    }
    unsafe fn requiresFlushToResumeDecoding(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiresFlushToResumeDecoding)
    }
}
impl AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererPixelBufferOutput
    for AVSampleBufferVideoRenderer
{
}
pub trait AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererPixelBufferOutput:
    Sized + std::ops::Deref
{
    unsafe fn copyDisplayedPixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, copyDisplayedPixelBuffer)
    }
}
impl AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererPowerOptimization
    for AVSampleBufferVideoRenderer
{
}
pub trait AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererPowerOptimization:
    Sized + std::ops::Deref
{
    unsafe fn expectMinimumUpcomingSampleBufferPresentationTime_(
        &self,
        minimumUpcomingPresentationTime: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, expectMinimumUpcomingSampleBufferPresentationTime : minimumUpcomingPresentationTime)
    }
    unsafe fn expectMonotonicallyIncreasingUpcomingSampleBufferPresentationTimes(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expectMonotonicallyIncreasingUpcomingSampleBufferPresentationTimes)
    }
    unsafe fn resetUpcomingSampleBufferPresentationTimeExpectations(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resetUpcomingSampleBufferPresentationTimeExpectations)
    }
    unsafe fn recommendedPixelBufferAttributes(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recommendedPixelBufferAttributes)
    }
}
impl AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererVideoPerformanceMetrics
    for AVSampleBufferVideoRenderer
{
}
pub trait AVSampleBufferVideoRenderer_AVSampleBufferVideoRendererVideoPerformanceMetrics:
    Sized + std::ops::Deref
{
    unsafe fn loadVideoPerformanceMetricsWithCompletionHandler_(
        &self,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, loadVideoPerformanceMetricsWithCompletionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSynchronizedLayer(pub id);
impl std::ops::Deref for AVSynchronizedLayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSynchronizedLayer {}
impl AVSynchronizedLayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSynchronizedLayer").unwrap(), alloc) })
    }
}
impl ICALayer for AVSynchronizedLayer {}
impl PNSSecureCoding for AVSynchronizedLayer {}
impl PCAMediaTiming for AVSynchronizedLayer {}
impl std::convert::TryFrom<CALayer> for AVSynchronizedLayer {
    type Error = &'static str;
    fn try_from(parent: CALayer) -> Result<AVSynchronizedLayer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSynchronizedLayer").unwrap()) };
        if is_kind_of {
            Ok(AVSynchronizedLayer(parent.0))
        } else {
            Err("This CALayer cannot be downcasted to AVSynchronizedLayer")
        }
    }
}
impl INSObject for AVSynchronizedLayer {}
impl PNSObject for AVSynchronizedLayer {}
impl IAVSynchronizedLayer for AVSynchronizedLayer {}
pub trait IAVSynchronizedLayer: Sized + std::ops::Deref {
    unsafe fn playerItem(&self) -> AVPlayerItem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, playerItem)
    }
    unsafe fn setPlayerItem_(&self, playerItem: AVPlayerItem)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPlayerItem : playerItem)
    }
    unsafe fn synchronizedLayerWithPlayerItem_(playerItem: AVPlayerItem) -> AVSynchronizedLayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSynchronizedLayer").unwrap(), synchronizedLayerWithPlayerItem : playerItem)
    }
}
pub trait NSValue_NSValueAVFoundationExtensions: Sized + std::ops::Deref {
    unsafe fn CMTimeValue(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, CMTimeValue)
    }
    unsafe fn CMTimeRangeValue(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, CMTimeRangeValue)
    }
    unsafe fn CMTimeMappingValue(&self) -> CMTimeMapping
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, CMTimeMappingValue)
    }
    unsafe fn valueWithCMTime_(time: CMTime) -> NSValue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"NSValue").unwrap(), valueWithCMTime : time)
    }
    unsafe fn valueWithCMTimeRange_(timeRange: CMTimeRange) -> NSValue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"NSValue").unwrap(), valueWithCMTimeRange : timeRange)
    }
    unsafe fn valueWithCMTimeMapping_(timeMapping: CMTimeMapping) -> NSValue
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"NSValue").unwrap(), valueWithCMTimeMapping : timeMapping)
    }
}
pub trait NSCoder_AVTimeCoding: Sized + std::ops::Deref {
    unsafe fn encodeCMTime_forKey_(&self, time: CMTime, key: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, encodeCMTime : time, forKey : key)
    }
    unsafe fn decodeCMTimeForKey_(&self, key: NSString) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, decodeCMTimeForKey : key)
    }
    unsafe fn encodeCMTimeRange_forKey_(&self, timeRange: CMTimeRange, key: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, encodeCMTimeRange : timeRange, forKey : key)
    }
    unsafe fn decodeCMTimeRangeForKey_(&self, key: NSString) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, decodeCMTimeRangeForKey : key)
    }
    unsafe fn encodeCMTimeMapping_forKey_(&self, timeMapping: CMTimeMapping, key: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, encodeCMTimeMapping : timeMapping, forKey : key)
    }
    unsafe fn decodeCMTimeMappingForKey_(&self, key: NSString) -> CMTimeMapping
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, decodeCMTimeMappingForKey : key)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVVideoPerformanceMetrics(pub id);
impl std::ops::Deref for AVVideoPerformanceMetrics {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVVideoPerformanceMetrics {}
impl AVVideoPerformanceMetrics {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoPerformanceMetrics").unwrap(), alloc) })
    }
}
impl INSObject for AVVideoPerformanceMetrics {}
impl PNSObject for AVVideoPerformanceMetrics {}
impl std::convert::TryFrom<NSObject> for AVVideoPerformanceMetrics {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVVideoPerformanceMetrics, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVVideoPerformanceMetrics").unwrap()) };
        if is_kind_of {
            Ok(AVVideoPerformanceMetrics(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVVideoPerformanceMetrics")
        }
    }
}
impl IAVVideoPerformanceMetrics for AVVideoPerformanceMetrics {}
pub trait IAVVideoPerformanceMetrics: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn totalNumberOfFrames(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalNumberOfFrames)
    }
    unsafe fn numberOfDroppedFrames(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfDroppedFrames)
    }
    unsafe fn numberOfCorruptedFrames(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfCorruptedFrames)
    }
    unsafe fn numberOfFramesDisplayedUsingOptimizedCompositing(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfFramesDisplayedUsingOptimizedCompositing)
    }
    unsafe fn totalAccumulatedFrameDelay(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalAccumulatedFrameDelay)
    }
    unsafe fn totalNumberOfVideoFrames(&self) -> ::std::os::raw::c_ulong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalNumberOfVideoFrames)
    }
    unsafe fn numberOfDroppedVideoFrames(&self) -> ::std::os::raw::c_ulong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfDroppedVideoFrames)
    }
    unsafe fn numberOfCorruptedVideoFrames(&self) -> ::std::os::raw::c_ulong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfCorruptedVideoFrames)
    }
    unsafe fn numberOfDisplayCompositedVideoFrames(&self) -> ::std::os::raw::c_ulong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfDisplayCompositedVideoFrames)
    }
    unsafe fn numberOfNonDisplayCompositedVideoFrames(&self) -> ::std::os::raw::c_ulong
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfNonDisplayCompositedVideoFrames)
    }
    unsafe fn totalFrameDelay(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalFrameDelay)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVVideoPerformanceMetrics").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCameraCalibrationData(pub id);
impl std::ops::Deref for AVCameraCalibrationData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCameraCalibrationData {}
impl AVCameraCalibrationData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCameraCalibrationData").unwrap(), alloc) })
    }
}
impl INSObject for AVCameraCalibrationData {}
impl PNSObject for AVCameraCalibrationData {}
impl std::convert::TryFrom<NSObject> for AVCameraCalibrationData {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCameraCalibrationData, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCameraCalibrationData").unwrap()) };
        if is_kind_of {
            Ok(AVCameraCalibrationData(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCameraCalibrationData")
        }
    }
}
impl IAVCameraCalibrationData for AVCameraCalibrationData {}
pub trait IAVCameraCalibrationData: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn intrinsicMatrix(&self) -> matrix_float3x3
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, intrinsicMatrix)
    }
    unsafe fn intrinsicMatrixReferenceDimensions(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, intrinsicMatrixReferenceDimensions)
    }
    unsafe fn extrinsicMatrix(&self) -> matrix_float4x3
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, extrinsicMatrix)
    }
    unsafe fn pixelSize(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelSize)
    }
    unsafe fn lensDistortionLookupTable(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lensDistortionLookupTable)
    }
    unsafe fn inverseLensDistortionLookupTable(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inverseLensDistortionLookupTable)
    }
    unsafe fn lensDistortionCenter(&self) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lensDistortionCenter)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCameraCalibrationData").unwrap(), new)
    }
}
pub type AVCaptureSessionPreset = NSString;
pub type AVCaptureReactionType = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureReactionEffectState(pub id);
impl std::ops::Deref for AVCaptureReactionEffectState {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureReactionEffectState {}
impl AVCaptureReactionEffectState {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureReactionEffectState").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureReactionEffectState {}
impl PNSObject for AVCaptureReactionEffectState {}
impl std::convert::TryFrom<NSObject> for AVCaptureReactionEffectState {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureReactionEffectState, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureReactionEffectState").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureReactionEffectState(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureReactionEffectState")
        }
    }
}
impl IAVCaptureReactionEffectState for AVCaptureReactionEffectState {}
pub trait IAVCaptureReactionEffectState: Sized + std::ops::Deref {
    unsafe fn reactionType(&self) -> AVCaptureReactionType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reactionType)
    }
    unsafe fn startTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startTime)
    }
    unsafe fn endTime(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, endTime)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDevice(pub id);
impl std::ops::Deref for AVCaptureDevice {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDevice {}
impl AVCaptureDevice {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDevice {}
impl PNSObject for AVCaptureDevice {}
impl std::convert::TryFrom<NSObject> for AVCaptureDevice {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDevice, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDevice(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDevice")
        }
    }
}
impl IAVCaptureDevice for AVCaptureDevice {}
pub trait IAVCaptureDevice: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn hasMediaType_(&self, mediaType: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, hasMediaType : mediaType)
    }
    unsafe fn lockForConfiguration_(&self, outError: *mut NSError) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, lockForConfiguration : outError)
    }
    unsafe fn unlockForConfiguration(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unlockForConfiguration)
    }
    unsafe fn supportsAVCaptureSessionPreset_(&self, preset: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportsAVCaptureSessionPreset : preset)
    }
    unsafe fn uniqueID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uniqueID)
    }
    unsafe fn modelID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, modelID)
    }
    unsafe fn localizedName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedName)
    }
    unsafe fn manufacturer(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, manufacturer)
    }
    unsafe fn transportType(&self) -> i32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transportType)
    }
    unsafe fn isConnected(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConnected)
    }
    unsafe fn isInUseByAnotherApplication(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isInUseByAnotherApplication)
    }
    unsafe fn isSuspended(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSuspended)
    }
    unsafe fn linkedDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, linkedDevices)
    }
    unsafe fn formats(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formats)
    }
    unsafe fn activeFormat(&self) -> AVCaptureDeviceFormat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeFormat)
    }
    unsafe fn setActiveFormat_(&self, activeFormat: AVCaptureDeviceFormat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveFormat : activeFormat)
    }
    unsafe fn activeVideoMinFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeVideoMinFrameDuration)
    }
    unsafe fn setActiveVideoMinFrameDuration_(&self, activeVideoMinFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveVideoMinFrameDuration : activeVideoMinFrameDuration)
    }
    unsafe fn activeVideoMaxFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeVideoMaxFrameDuration)
    }
    unsafe fn setActiveVideoMaxFrameDuration_(&self, activeVideoMaxFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveVideoMaxFrameDuration : activeVideoMaxFrameDuration)
    }
    unsafe fn isVideoFrameDurationLocked(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoFrameDurationLocked)
    }
    unsafe fn minSupportedLockedVideoFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minSupportedLockedVideoFrameDuration)
    }
    unsafe fn isFollowingExternalSyncDevice(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFollowingExternalSyncDevice)
    }
    unsafe fn minSupportedExternalSyncFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minSupportedExternalSyncFrameDuration)
    }
    unsafe fn isAutoVideoFrameRateEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoVideoFrameRateEnabled)
    }
    unsafe fn setAutoVideoFrameRateEnabled_(&self, autoVideoFrameRateEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoVideoFrameRateEnabled : autoVideoFrameRateEnabled)
    }
    unsafe fn inputSources(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputSources)
    }
    unsafe fn activeInputSource(&self) -> AVCaptureDeviceInputSource
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeInputSource)
    }
    unsafe fn setActiveInputSource_(&self, activeInputSource: AVCaptureDeviceInputSource)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveInputSource : activeInputSource)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), new)
    }
    unsafe fn devices() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), devices)
    }
    unsafe fn devicesWithMediaType_(mediaType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), devicesWithMediaType : mediaType)
    }
    unsafe fn defaultDeviceWithMediaType_(mediaType: NSString) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), defaultDeviceWithMediaType : mediaType)
    }
    unsafe fn deviceWithUniqueID_(deviceUniqueID: NSString) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), deviceWithUniqueID : deviceUniqueID)
    }
}
pub type AVCaptureDevicePosition = NSInteger;
impl AVCaptureDevice_AVCaptureDevicePosition for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDevicePosition: Sized + std::ops::Deref {
    unsafe fn position(&self) -> AVCaptureDevicePosition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, position)
    }
}
pub type AVCaptureDeviceType = NSString;
impl AVCaptureDevice_AVCaptureDeviceType for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceType: Sized + std::ops::Deref {
    unsafe fn deviceType(&self) -> AVCaptureDeviceType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deviceType)
    }
}
impl AVCaptureDevice_AVCaptureDefaultDevice for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDefaultDevice: Sized + std::ops::Deref {
    unsafe fn defaultDeviceWithDeviceType_mediaType_position_(
        deviceType: NSString,
        mediaType: NSString,
        position: AVCaptureDevicePosition,
    ) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), defaultDeviceWithDeviceType : deviceType, mediaType : mediaType, position : position)
    }
}
impl AVCaptureDevice_AVCaptureDevicePreferredCamera for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDevicePreferredCamera: Sized + std::ops::Deref {
    unsafe fn userPreferredCamera() -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), userPreferredCamera)
    }
    unsafe fn setUserPreferredCamera_(userPreferredCamera: AVCaptureDevice)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), setUserPreferredCamera : userPreferredCamera)
    }
    unsafe fn systemPreferredCamera() -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), systemPreferredCamera)
    }
}
impl AVCaptureDevice_AVCaptureDeviceSystemPressure for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceSystemPressure: Sized + std::ops::Deref {
    unsafe fn systemPressureState(&self) -> AVCaptureSystemPressureState
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, systemPressureState)
    }
}
pub type AVCapturePrimaryConstituentDeviceSwitchingBehavior = NSInteger;
pub type AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions = NSUInteger;
impl AVCaptureDevice_AVCaptureDeviceVirtual for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceVirtual: Sized + std::ops::Deref {
    unsafe fn setPrimaryConstituentDeviceSwitchingBehavior_restrictedSwitchingBehaviorConditions_(
        &self,
        switchingBehavior: AVCapturePrimaryConstituentDeviceSwitchingBehavior,
        restrictedSwitchingBehaviorConditions : AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPrimaryConstituentDeviceSwitchingBehavior : switchingBehavior, restrictedSwitchingBehaviorConditions : restrictedSwitchingBehaviorConditions)
    }
    unsafe fn isVirtualDevice(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVirtualDevice)
    }
    unsafe fn constituentDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, constituentDevices)
    }
    unsafe fn virtualDeviceSwitchOverVideoZoomFactors(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, virtualDeviceSwitchOverVideoZoomFactors)
    }
    unsafe fn primaryConstituentDeviceSwitchingBehavior(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceSwitchingBehavior
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryConstituentDeviceSwitchingBehavior)
    }
    unsafe fn primaryConstituentDeviceRestrictedSwitchingBehaviorConditions(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryConstituentDeviceRestrictedSwitchingBehaviorConditions)
    }
    unsafe fn activePrimaryConstituentDeviceSwitchingBehavior(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceSwitchingBehavior
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activePrimaryConstituentDeviceSwitchingBehavior)
    }
    unsafe fn activePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions)
    }
    unsafe fn activePrimaryConstituentDevice(&self) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activePrimaryConstituentDevice)
    }
    unsafe fn supportedFallbackPrimaryConstituentDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedFallbackPrimaryConstituentDevices)
    }
    unsafe fn fallbackPrimaryConstituentDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, fallbackPrimaryConstituentDevices)
    }
    unsafe fn setFallbackPrimaryConstituentDevices_(
        &self,
        fallbackPrimaryConstituentDevices: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFallbackPrimaryConstituentDevices : fallbackPrimaryConstituentDevices)
    }
}
pub type AVCaptureFlashMode = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceFlash for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceFlash: Sized + std::ops::Deref {
    unsafe fn isFlashModeSupported_(&self, flashMode: AVCaptureFlashMode) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isFlashModeSupported : flashMode)
    }
    unsafe fn hasFlash(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasFlash)
    }
    unsafe fn isFlashAvailable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFlashAvailable)
    }
    unsafe fn isFlashActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFlashActive)
    }
    unsafe fn flashMode(&self) -> AVCaptureFlashMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flashMode)
    }
    unsafe fn setFlashMode_(&self, flashMode: AVCaptureFlashMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFlashMode : flashMode)
    }
}
pub type AVCaptureTorchMode = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceTorch for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceTorch: Sized + std::ops::Deref {
    unsafe fn isTorchModeSupported_(&self, torchMode: AVCaptureTorchMode) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isTorchModeSupported : torchMode)
    }
    unsafe fn setTorchModeOnWithLevel_error_(&self, torchLevel: f32, outError: *mut NSError) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTorchModeOnWithLevel : torchLevel, error : outError)
    }
    unsafe fn hasTorch(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasTorch)
    }
    unsafe fn isTorchAvailable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isTorchAvailable)
    }
    unsafe fn isTorchActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isTorchActive)
    }
    unsafe fn torchLevel(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, torchLevel)
    }
    unsafe fn torchMode(&self) -> AVCaptureTorchMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, torchMode)
    }
    unsafe fn setTorchMode_(&self, torchMode: AVCaptureTorchMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTorchMode : torchMode)
    }
}
pub type AVCaptureFocusMode = NSInteger;
pub type AVCaptureAutoFocusRangeRestriction = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceFocus for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceFocus: Sized + std::ops::Deref {
    unsafe fn isFocusModeSupported_(&self, focusMode: AVCaptureFocusMode) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isFocusModeSupported : focusMode)
    }
    unsafe fn defaultRectForFocusPointOfInterest_(&self, pointOfInterest: CGPoint) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, defaultRectForFocusPointOfInterest : pointOfInterest)
    }
    unsafe fn setFocusModeLockedWithLensPosition_completionHandler_(
        &self,
        lensPosition: f32,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFocusModeLockedWithLensPosition : lensPosition, completionHandler : handler)
    }
    unsafe fn setCinematicVideoTrackingFocusWithDetectedObjectID_focusMode_(
        &self,
        detectedObjectID: NSInteger,
        focusMode: AVCaptureCinematicVideoFocusMode,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCinematicVideoTrackingFocusWithDetectedObjectID : detectedObjectID, focusMode : focusMode)
    }
    unsafe fn setCinematicVideoTrackingFocusAtPoint_focusMode_(
        &self,
        point: CGPoint,
        focusMode: AVCaptureCinematicVideoFocusMode,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCinematicVideoTrackingFocusAtPoint : point, focusMode : focusMode)
    }
    unsafe fn setCinematicVideoFixedFocusAtPoint_focusMode_(
        &self,
        point: CGPoint,
        focusMode: AVCaptureCinematicVideoFocusMode,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCinematicVideoFixedFocusAtPoint : point, focusMode : focusMode)
    }
    unsafe fn isLockingFocusWithCustomLensPositionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLockingFocusWithCustomLensPositionSupported)
    }
    unsafe fn focusMode(&self) -> AVCaptureFocusMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, focusMode)
    }
    unsafe fn setFocusMode_(&self, focusMode: AVCaptureFocusMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFocusMode : focusMode)
    }
    unsafe fn isFocusPointOfInterestSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFocusPointOfInterestSupported)
    }
    unsafe fn focusPointOfInterest(&self) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, focusPointOfInterest)
    }
    unsafe fn setFocusPointOfInterest_(&self, focusPointOfInterest: CGPoint)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFocusPointOfInterest : focusPointOfInterest)
    }
    unsafe fn isFocusRectOfInterestSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFocusRectOfInterestSupported)
    }
    unsafe fn minFocusRectOfInterestSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFocusRectOfInterestSize)
    }
    unsafe fn focusRectOfInterest(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, focusRectOfInterest)
    }
    unsafe fn setFocusRectOfInterest_(&self, focusRectOfInterest: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFocusRectOfInterest : focusRectOfInterest)
    }
    unsafe fn isAdjustingFocus(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAdjustingFocus)
    }
    unsafe fn isAutoFocusRangeRestrictionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoFocusRangeRestrictionSupported)
    }
    unsafe fn autoFocusRangeRestriction(&self) -> AVCaptureAutoFocusRangeRestriction
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, autoFocusRangeRestriction)
    }
    unsafe fn setAutoFocusRangeRestriction_(
        &self,
        autoFocusRangeRestriction: AVCaptureAutoFocusRangeRestriction,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoFocusRangeRestriction : autoFocusRangeRestriction)
    }
    unsafe fn isSmoothAutoFocusSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSmoothAutoFocusSupported)
    }
    unsafe fn isSmoothAutoFocusEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSmoothAutoFocusEnabled)
    }
    unsafe fn setSmoothAutoFocusEnabled_(&self, smoothAutoFocusEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSmoothAutoFocusEnabled : smoothAutoFocusEnabled)
    }
    unsafe fn automaticallyAdjustsFaceDrivenAutoFocusEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyAdjustsFaceDrivenAutoFocusEnabled)
    }
    unsafe fn setAutomaticallyAdjustsFaceDrivenAutoFocusEnabled_(
        &self,
        automaticallyAdjustsFaceDrivenAutoFocusEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyAdjustsFaceDrivenAutoFocusEnabled : automaticallyAdjustsFaceDrivenAutoFocusEnabled)
    }
    unsafe fn isFaceDrivenAutoFocusEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFaceDrivenAutoFocusEnabled)
    }
    unsafe fn setFaceDrivenAutoFocusEnabled_(&self, faceDrivenAutoFocusEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFaceDrivenAutoFocusEnabled : faceDrivenAutoFocusEnabled)
    }
    unsafe fn lensPosition(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lensPosition)
    }
    unsafe fn minimumFocusDistance(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minimumFocusDistance)
    }
}
pub type AVCaptureCinematicVideoFocusMode = NSInteger;
pub type AVCaptureExposureMode = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceExposure for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceExposure: Sized + std::ops::Deref {
    unsafe fn isExposureModeSupported_(&self, exposureMode: AVCaptureExposureMode) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isExposureModeSupported : exposureMode)
    }
    unsafe fn defaultRectForExposurePointOfInterest_(&self, pointOfInterest: CGPoint) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, defaultRectForExposurePointOfInterest : pointOfInterest)
    }
    unsafe fn setExposureModeCustomWithDuration_ISO_completionHandler_(
        &self,
        duration: CMTime,
        ISO: f32,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExposureModeCustomWithDuration : duration, ISO : ISO, completionHandler : handler)
    }
    unsafe fn setExposureTargetBias_completionHandler_(
        &self,
        bias: f32,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExposureTargetBias : bias, completionHandler : handler)
    }
    unsafe fn exposureMode(&self) -> AVCaptureExposureMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureMode)
    }
    unsafe fn setExposureMode_(&self, exposureMode: AVCaptureExposureMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExposureMode : exposureMode)
    }
    unsafe fn isExposurePointOfInterestSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isExposurePointOfInterestSupported)
    }
    unsafe fn exposurePointOfInterest(&self) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposurePointOfInterest)
    }
    unsafe fn setExposurePointOfInterest_(&self, exposurePointOfInterest: CGPoint)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExposurePointOfInterest : exposurePointOfInterest)
    }
    unsafe fn isExposureRectOfInterestSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isExposureRectOfInterestSupported)
    }
    unsafe fn minExposureRectOfInterestSize(&self) -> CGSize
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minExposureRectOfInterestSize)
    }
    unsafe fn exposureRectOfInterest(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureRectOfInterest)
    }
    unsafe fn setExposureRectOfInterest_(&self, exposureRectOfInterest: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setExposureRectOfInterest : exposureRectOfInterest)
    }
    unsafe fn automaticallyAdjustsFaceDrivenAutoExposureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyAdjustsFaceDrivenAutoExposureEnabled)
    }
    unsafe fn setAutomaticallyAdjustsFaceDrivenAutoExposureEnabled_(
        &self,
        automaticallyAdjustsFaceDrivenAutoExposureEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyAdjustsFaceDrivenAutoExposureEnabled : automaticallyAdjustsFaceDrivenAutoExposureEnabled)
    }
    unsafe fn isFaceDrivenAutoExposureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFaceDrivenAutoExposureEnabled)
    }
    unsafe fn setFaceDrivenAutoExposureEnabled_(&self, faceDrivenAutoExposureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFaceDrivenAutoExposureEnabled : faceDrivenAutoExposureEnabled)
    }
    unsafe fn activeMaxExposureDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeMaxExposureDuration)
    }
    unsafe fn setActiveMaxExposureDuration_(&self, activeMaxExposureDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveMaxExposureDuration : activeMaxExposureDuration)
    }
    unsafe fn isAdjustingExposure(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAdjustingExposure)
    }
    unsafe fn lensAperture(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lensAperture)
    }
    unsafe fn exposureDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureDuration)
    }
    unsafe fn ISO(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, ISO)
    }
    unsafe fn exposureTargetOffset(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureTargetOffset)
    }
    unsafe fn exposureTargetBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureTargetBias)
    }
    unsafe fn minExposureTargetBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minExposureTargetBias)
    }
    unsafe fn maxExposureTargetBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxExposureTargetBias)
    }
}
impl AVCaptureDevice_AVCaptureDeviceToneMapping for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceToneMapping: Sized + std::ops::Deref {
    unsafe fn isGlobalToneMappingEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isGlobalToneMappingEnabled)
    }
    unsafe fn setGlobalToneMappingEnabled_(&self, globalToneMappingEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setGlobalToneMappingEnabled : globalToneMappingEnabled)
    }
}
pub type AVCaptureWhiteBalanceMode = NSInteger;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureWhiteBalanceGains {
    pub redGain: f32,
    pub greenGain: f32,
    pub blueGain: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureWhiteBalanceChromaticityValues {
    pub x: f32,
    pub y: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureWhiteBalanceTemperatureAndTintValues {
    pub temperature: f32,
    pub tint: f32,
}
impl AVCaptureDevice_AVCaptureDeviceWhiteBalance for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceWhiteBalance: Sized + std::ops::Deref {
    unsafe fn isWhiteBalanceModeSupported_(
        &self,
        whiteBalanceMode: AVCaptureWhiteBalanceMode,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isWhiteBalanceModeSupported : whiteBalanceMode)
    }
    unsafe fn setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues_completionHandler_(
        &self,
        whiteBalanceTemperatureAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues : whiteBalanceTemperatureAndTintValues, completionHandler : handler)
    }
    unsafe fn setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains_completionHandler_(
        &self,
        whiteBalanceGains: AVCaptureWhiteBalanceGains,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains : whiteBalanceGains, completionHandler : handler)
    }
    unsafe fn chromaticityValuesForDeviceWhiteBalanceGains_(
        &self,
        whiteBalanceGains: AVCaptureWhiteBalanceGains,
    ) -> AVCaptureWhiteBalanceChromaticityValues
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, chromaticityValuesForDeviceWhiteBalanceGains : whiteBalanceGains)
    }
    unsafe fn deviceWhiteBalanceGainsForChromaticityValues_(
        &self,
        chromaticityValues: AVCaptureWhiteBalanceChromaticityValues,
    ) -> AVCaptureWhiteBalanceGains
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, deviceWhiteBalanceGainsForChromaticityValues : chromaticityValues)
    }
    unsafe fn temperatureAndTintValuesForDeviceWhiteBalanceGains_(
        &self,
        whiteBalanceGains: AVCaptureWhiteBalanceGains,
    ) -> AVCaptureWhiteBalanceTemperatureAndTintValues
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, temperatureAndTintValuesForDeviceWhiteBalanceGains : whiteBalanceGains)
    }
    unsafe fn deviceWhiteBalanceGainsForTemperatureAndTintValues_(
        &self,
        tempAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues,
    ) -> AVCaptureWhiteBalanceGains
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, deviceWhiteBalanceGainsForTemperatureAndTintValues : tempAndTintValues)
    }
    unsafe fn isLockingWhiteBalanceWithCustomDeviceGainsSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLockingWhiteBalanceWithCustomDeviceGainsSupported)
    }
    unsafe fn whiteBalanceMode(&self) -> AVCaptureWhiteBalanceMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, whiteBalanceMode)
    }
    unsafe fn setWhiteBalanceMode_(&self, whiteBalanceMode: AVCaptureWhiteBalanceMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWhiteBalanceMode : whiteBalanceMode)
    }
    unsafe fn isAdjustingWhiteBalance(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAdjustingWhiteBalance)
    }
    unsafe fn deviceWhiteBalanceGains(&self) -> AVCaptureWhiteBalanceGains
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deviceWhiteBalanceGains)
    }
    unsafe fn grayWorldDeviceWhiteBalanceGains(&self) -> AVCaptureWhiteBalanceGains
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, grayWorldDeviceWhiteBalanceGains)
    }
    unsafe fn maxWhiteBalanceGain(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxWhiteBalanceGain)
    }
}
impl AVCaptureDevice_AVCaptureDeviceSubjectAreaChangeMonitoring for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceSubjectAreaChangeMonitoring:
    Sized + std::ops::Deref
{
    unsafe fn isSubjectAreaChangeMonitoringEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSubjectAreaChangeMonitoringEnabled)
    }
    unsafe fn setSubjectAreaChangeMonitoringEnabled_(
        &self,
        subjectAreaChangeMonitoringEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSubjectAreaChangeMonitoringEnabled : subjectAreaChangeMonitoringEnabled)
    }
}
impl AVCaptureDevice_AVCaptureDeviceLowLightBoost for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceLowLightBoost: Sized + std::ops::Deref {
    unsafe fn isLowLightBoostSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLowLightBoostSupported)
    }
    unsafe fn isLowLightBoostEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLowLightBoostEnabled)
    }
    unsafe fn automaticallyEnablesLowLightBoostWhenAvailable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyEnablesLowLightBoostWhenAvailable)
    }
    unsafe fn setAutomaticallyEnablesLowLightBoostWhenAvailable_(
        &self,
        automaticallyEnablesLowLightBoostWhenAvailable: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyEnablesLowLightBoostWhenAvailable : automaticallyEnablesLowLightBoostWhenAvailable)
    }
}
impl AVCaptureDevice_AVCaptureDeviceVideoZoom for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceVideoZoom: Sized + std::ops::Deref {
    unsafe fn rampToVideoZoomFactor_withRate_(&self, factor: CGFloat, rate: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, rampToVideoZoomFactor : factor, withRate : rate)
    }
    unsafe fn cancelVideoZoomRamp(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cancelVideoZoomRamp)
    }
    unsafe fn videoZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoZoomFactor)
    }
    unsafe fn setVideoZoomFactor_(&self, videoZoomFactor: CGFloat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoZoomFactor : videoZoomFactor)
    }
    unsafe fn isRampingVideoZoom(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRampingVideoZoom)
    }
    unsafe fn dualCameraSwitchOverVideoZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dualCameraSwitchOverVideoZoomFactor)
    }
    unsafe fn displayVideoZoomFactorMultiplier(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayVideoZoomFactorMultiplier)
    }
}
pub type AVAuthorizationStatus = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceAuthorization for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceAuthorization: Sized + std::ops::Deref {
    unsafe fn authorizationStatusForMediaType_(mediaType: NSString) -> AVAuthorizationStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), authorizationStatusForMediaType : mediaType)
    }
    unsafe fn requestAccessForMediaType_completionHandler_(
        mediaType: NSString,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), requestAccessForMediaType : mediaType, completionHandler : handler)
    }
}
pub type AVCaptureDeviceTransportControlsSpeed = f32;
pub type AVCaptureDeviceTransportControlsPlaybackMode = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceTransportControls for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceTransportControls: Sized + std::ops::Deref {
    unsafe fn setTransportControlsPlaybackMode_speed_(
        &self,
        mode: AVCaptureDeviceTransportControlsPlaybackMode,
        speed: AVCaptureDeviceTransportControlsSpeed,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTransportControlsPlaybackMode : mode, speed : speed)
    }
    unsafe fn transportControlsSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transportControlsSupported)
    }
    unsafe fn transportControlsPlaybackMode(&self) -> AVCaptureDeviceTransportControlsPlaybackMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transportControlsPlaybackMode)
    }
    unsafe fn transportControlsSpeed(&self) -> AVCaptureDeviceTransportControlsSpeed
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, transportControlsSpeed)
    }
}
impl AVCaptureDevice_AVCaptureDeviceHighDynamicRangeSupport for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceHighDynamicRangeSupport: Sized + std::ops::Deref {
    unsafe fn automaticallyAdjustsVideoHDREnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyAdjustsVideoHDREnabled)
    }
    unsafe fn setAutomaticallyAdjustsVideoHDREnabled_(
        &self,
        automaticallyAdjustsVideoHDREnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyAdjustsVideoHDREnabled : automaticallyAdjustsVideoHDREnabled)
    }
    unsafe fn isVideoHDREnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoHDREnabled)
    }
    unsafe fn setVideoHDREnabled_(&self, videoHDREnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoHDREnabled : videoHDREnabled)
    }
}
pub type AVCaptureColorSpace = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceColorSpaceSupport for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceColorSpaceSupport: Sized + std::ops::Deref {
    unsafe fn activeColorSpace(&self) -> AVCaptureColorSpace
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeColorSpace)
    }
    unsafe fn setActiveColorSpace_(&self, activeColorSpace: AVCaptureColorSpace)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveColorSpace : activeColorSpace)
    }
}
impl AVCaptureDevice_AVCaptureDeviceDepthSupport for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceDepthSupport: Sized + std::ops::Deref {
    unsafe fn activeDepthDataFormat(&self) -> AVCaptureDeviceFormat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeDepthDataFormat)
    }
    unsafe fn setActiveDepthDataFormat_(&self, activeDepthDataFormat: AVCaptureDeviceFormat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveDepthDataFormat : activeDepthDataFormat)
    }
    unsafe fn activeDepthDataMinFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeDepthDataMinFrameDuration)
    }
    unsafe fn setActiveDepthDataMinFrameDuration_(&self, activeDepthDataMinFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveDepthDataMinFrameDuration : activeDepthDataMinFrameDuration)
    }
    unsafe fn minAvailableVideoZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minAvailableVideoZoomFactor)
    }
    unsafe fn maxAvailableVideoZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxAvailableVideoZoomFactor)
    }
}
impl AVCaptureDevice_AVCaptureDeviceGeometricDistortionCorrection for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceGeometricDistortionCorrection:
    Sized + std::ops::Deref
{
    unsafe fn isGeometricDistortionCorrectionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isGeometricDistortionCorrectionSupported)
    }
    unsafe fn isGeometricDistortionCorrectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isGeometricDistortionCorrectionEnabled)
    }
    unsafe fn setGeometricDistortionCorrectionEnabled_(
        &self,
        geometricDistortionCorrectionEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setGeometricDistortionCorrectionEnabled : geometricDistortionCorrectionEnabled)
    }
}
impl AVCaptureDevice_AVCaptureDeviceCalibration for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceCalibration: Sized + std::ops::Deref {
    unsafe fn extrinsicMatrixFromDevice_toDevice_(
        fromDevice: AVCaptureDevice,
        toDevice: AVCaptureDevice,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), extrinsicMatrixFromDevice : fromDevice, toDevice : toDevice)
    }
}
impl AVCaptureDevice_AVCaptureDeviceCenterStage for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceCenterStage: Sized + std::ops::Deref {
    unsafe fn isCenterStageActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCenterStageActive)
    }
    unsafe fn isCenterStageRectOfInterestSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCenterStageRectOfInterestSupported)
    }
    unsafe fn centerStageRectOfInterest(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, centerStageRectOfInterest)
    }
    unsafe fn setCenterStageRectOfInterest_(&self, centerStageRectOfInterest: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCenterStageRectOfInterest : centerStageRectOfInterest)
    }
    unsafe fn centerStageControlMode() -> AVCaptureCenterStageControlMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), centerStageControlMode)
    }
    unsafe fn setCenterStageControlMode_(centerStageControlMode: AVCaptureCenterStageControlMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), setCenterStageControlMode : centerStageControlMode)
    }
    unsafe fn isCenterStageEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isCenterStageEnabled)
    }
    unsafe fn setCenterStageEnabled_(centerStageEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), setCenterStageEnabled : centerStageEnabled)
    }
}
pub type AVCaptureCenterStageControlMode = NSInteger;
impl AVCaptureDevice_AVCaptureDevicePortraitEffect for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDevicePortraitEffect: Sized + std::ops::Deref {
    unsafe fn isPortraitEffectActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectActive)
    }
    unsafe fn isPortraitEffectEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isPortraitEffectEnabled)
    }
}
impl AVCaptureDevice_AVCaptureDeviceReactionEffects for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceReactionEffects: Sized + std::ops::Deref {
    unsafe fn performEffectForReaction_(&self, reactionType: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, performEffectForReaction : reactionType)
    }
    unsafe fn canPerformReactionEffects(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, canPerformReactionEffects)
    }
    unsafe fn availableReactionTypes(&self) -> NSSet
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableReactionTypes)
    }
    unsafe fn reactionEffectsInProgress(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reactionEffectsInProgress)
    }
    unsafe fn reactionEffectsEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), reactionEffectsEnabled)
    }
    unsafe fn reactionEffectGesturesEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), reactionEffectGesturesEnabled)
    }
}
impl AVCaptureDevice_AVCaptureDeviceBackgroundReplacement for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceBackgroundReplacement: Sized + std::ops::Deref {
    unsafe fn isBackgroundReplacementActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isBackgroundReplacementActive)
    }
    unsafe fn isBackgroundReplacementEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isBackgroundReplacementEnabled)
    }
}
impl AVCaptureDevice_AVCaptureDeviceContinuityCamera for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceContinuityCamera: Sized + std::ops::Deref {
    unsafe fn isContinuityCamera(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isContinuityCamera)
    }
}
impl AVCaptureDevice_AVCaptureDeviceDeskViewCamera for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceDeskViewCamera: Sized + std::ops::Deref {
    unsafe fn companionDeskViewCamera(&self) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, companionDeskViewCamera)
    }
}
impl AVCaptureDevice_AVCaptureMicrophoneMode for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureMicrophoneMode: Sized + std::ops::Deref {
    unsafe fn preferredMicrophoneMode() -> AVCaptureMicrophoneMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), preferredMicrophoneMode)
    }
    unsafe fn activeMicrophoneMode() -> AVCaptureMicrophoneMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), activeMicrophoneMode)
    }
}
pub type AVCaptureMicrophoneMode = NSInteger;
impl AVCaptureDevice_AVCaptureSystemUserInterface for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureSystemUserInterface: Sized + std::ops::Deref {
    unsafe fn showSystemUserInterface_(systemUserInterface: AVCaptureSystemUserInterface)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), showSystemUserInterface : systemUserInterface)
    }
}
pub type AVCaptureSystemUserInterface = NSInteger;
impl AVCaptureDevice_AVCaptureDeviceSpatialCapture for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceSpatialCapture: Sized + std::ops::Deref {
    unsafe fn spatialCaptureDiscomfortReasons(&self) -> NSSet
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, spatialCaptureDiscomfortReasons)
    }
}
impl AVCaptureDevice_AVCaptureDeviceCinematicVideoCapture for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceCinematicVideoCapture: Sized + std::ops::Deref {
    unsafe fn cinematicVideoCaptureSceneMonitoringStatuses(&self) -> NSSet
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cinematicVideoCaptureSceneMonitoringStatuses)
    }
}
pub type AVCaptureAspectRatio = NSString;
impl AVCaptureDevice_DynamicAspectRatio for AVCaptureDevice {}
pub trait AVCaptureDevice_DynamicAspectRatio: Sized + std::ops::Deref {
    unsafe fn setDynamicAspectRatio_completionHandler_(
        &self,
        dynamicAspectRatio: NSString,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDynamicAspectRatio : dynamicAspectRatio, completionHandler : handler)
    }
    unsafe fn dynamicAspectRatio(&self) -> AVCaptureAspectRatio
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dynamicAspectRatio)
    }
    unsafe fn dynamicDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dynamicDimensions)
    }
}
impl AVCaptureDevice_AVCaptureDeviceSmartFraming for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceSmartFraming: Sized + std::ops::Deref {
    unsafe fn smartFramingMonitor(&self) -> AVCaptureSmartFramingMonitor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, smartFramingMonitor)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSmartFramingMonitor(pub id);
impl std::ops::Deref for AVCaptureSmartFramingMonitor {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSmartFramingMonitor {}
impl AVCaptureSmartFramingMonitor {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSmartFramingMonitor").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureSmartFramingMonitor {}
impl PNSObject for AVCaptureSmartFramingMonitor {}
impl std::convert::TryFrom<NSObject> for AVCaptureSmartFramingMonitor {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureSmartFramingMonitor, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSmartFramingMonitor").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSmartFramingMonitor(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureSmartFramingMonitor")
        }
    }
}
impl IAVCaptureSmartFramingMonitor for AVCaptureSmartFramingMonitor {}
pub trait IAVCaptureSmartFramingMonitor: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn startMonitoringWithError_(&self, outError: *mut NSError) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startMonitoringWithError : outError)
    }
    unsafe fn stopMonitoring(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopMonitoring)
    }
    unsafe fn supportedFramings(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedFramings)
    }
    unsafe fn enabledFramings(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enabledFramings)
    }
    unsafe fn setEnabledFramings_(&self, enabledFramings: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabledFramings : enabledFramings)
    }
    unsafe fn recommendedFraming(&self) -> AVCaptureFraming
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recommendedFraming)
    }
    unsafe fn isMonitoring(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMonitoring)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSmartFramingMonitor").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureFraming(pub id);
impl std::ops::Deref for AVCaptureFraming {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureFraming {}
impl AVCaptureFraming {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureFraming").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureFraming {}
impl PNSObject for AVCaptureFraming {}
impl std::convert::TryFrom<NSObject> for AVCaptureFraming {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureFraming, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureFraming").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureFraming(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureFraming")
        }
    }
}
impl IAVCaptureFraming for AVCaptureFraming {}
pub trait IAVCaptureFraming: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn aspectRatio(&self) -> AVCaptureAspectRatio
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, aspectRatio)
    }
    unsafe fn zoomFactor(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, zoomFactor)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureFraming").unwrap(), new)
    }
}
impl AVCaptureDevice_AVCaptureDeviceNominalFocalLengthIn35mmFilm for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceNominalFocalLengthIn35mmFilm:
    Sized + std::ops::Deref
{
    unsafe fn nominalFocalLengthIn35mmFilm(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, nominalFocalLengthIn35mmFilm)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeviceDiscoverySession(pub id);
impl std::ops::Deref for AVCaptureDeviceDiscoverySession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeviceDiscoverySession {}
impl AVCaptureDeviceDiscoverySession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceDiscoverySession").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDeviceDiscoverySession {}
impl PNSObject for AVCaptureDeviceDiscoverySession {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeviceDiscoverySession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDeviceDiscoverySession, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeviceDiscoverySession").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureDeviceDiscoverySession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDeviceDiscoverySession")
        }
    }
}
impl IAVCaptureDeviceDiscoverySession for AVCaptureDeviceDiscoverySession {}
pub trait IAVCaptureDeviceDiscoverySession: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn devices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, devices)
    }
    unsafe fn supportedMultiCamDeviceSets(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedMultiCamDeviceSets)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceDiscoverySession").unwrap(), new)
    }
    unsafe fn discoverySessionWithDeviceTypes_mediaType_position_(
        deviceTypes: NSArray,
        mediaType: NSString,
        position: AVCaptureDevicePosition,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceDiscoverySession").unwrap(), discoverySessionWithDeviceTypes : deviceTypes, mediaType : mediaType, position : position)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeviceRotationCoordinator(pub id);
impl std::ops::Deref for AVCaptureDeviceRotationCoordinator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeviceRotationCoordinator {}
impl AVCaptureDeviceRotationCoordinator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceRotationCoordinator").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDeviceRotationCoordinator {}
impl PNSObject for AVCaptureDeviceRotationCoordinator {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeviceRotationCoordinator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDeviceRotationCoordinator, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeviceRotationCoordinator").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureDeviceRotationCoordinator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDeviceRotationCoordinator")
        }
    }
}
impl IAVCaptureDeviceRotationCoordinator for AVCaptureDeviceRotationCoordinator {}
pub trait IAVCaptureDeviceRotationCoordinator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithDevice_previewLayer_(
        &self,
        device: AVCaptureDevice,
        previewLayer: CALayer,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device, previewLayer : previewLayer)
    }
    unsafe fn device(&self) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, device)
    }
    unsafe fn previewLayer(&self) -> CALayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewLayer)
    }
    unsafe fn videoRotationAngleForHorizonLevelPreview(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRotationAngleForHorizonLevelPreview)
    }
    unsafe fn videoRotationAngleForHorizonLevelCapture(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRotationAngleForHorizonLevelCapture)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceRotationCoordinator").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVExposureBiasRange(pub id);
impl std::ops::Deref for AVExposureBiasRange {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVExposureBiasRange {}
impl AVExposureBiasRange {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVExposureBiasRange").unwrap(), alloc) })
    }
}
impl INSObject for AVExposureBiasRange {}
impl PNSObject for AVExposureBiasRange {}
impl std::convert::TryFrom<NSObject> for AVExposureBiasRange {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVExposureBiasRange, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVExposureBiasRange").unwrap()) };
        if is_kind_of {
            Ok(AVExposureBiasRange(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVExposureBiasRange")
        }
    }
}
impl IAVExposureBiasRange for AVExposureBiasRange {}
pub trait IAVExposureBiasRange: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn containsExposureBias_(&self, exposureBias: f32) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, containsExposureBias : exposureBias)
    }
    unsafe fn minExposureBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minExposureBias)
    }
    unsafe fn maxExposureBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxExposureBias)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExposureBiasRange").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVFrameRateRange(pub id);
impl std::ops::Deref for AVFrameRateRange {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVFrameRateRange {}
impl AVFrameRateRange {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVFrameRateRange").unwrap(), alloc) })
    }
}
impl INSObject for AVFrameRateRange {}
impl PNSObject for AVFrameRateRange {}
impl std::convert::TryFrom<NSObject> for AVFrameRateRange {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVFrameRateRange, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVFrameRateRange").unwrap()) };
        if is_kind_of {
            Ok(AVFrameRateRange(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVFrameRateRange")
        }
    }
}
impl IAVFrameRateRange for AVFrameRateRange {}
pub trait IAVFrameRateRange: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn minFrameRate(&self) -> Float64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFrameRate)
    }
    unsafe fn maxFrameRate(&self) -> Float64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxFrameRate)
    }
    unsafe fn maxFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxFrameDuration)
    }
    unsafe fn minFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFrameDuration)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVFrameRateRange").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVZoomRange(pub id);
impl std::ops::Deref for AVZoomRange {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVZoomRange {}
impl AVZoomRange {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVZoomRange").unwrap(), alloc) })
    }
}
impl INSObject for AVZoomRange {}
impl PNSObject for AVZoomRange {}
impl std::convert::TryFrom<NSObject> for AVZoomRange {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVZoomRange, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVZoomRange").unwrap()) };
        if is_kind_of {
            Ok(AVZoomRange(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVZoomRange")
        }
    }
}
impl IAVZoomRange for AVZoomRange {}
pub trait IAVZoomRange: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn containsZoomFactor_(&self, zoomFactor: CGFloat) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, containsZoomFactor : zoomFactor)
    }
    unsafe fn minZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minZoomFactor)
    }
    unsafe fn maxZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxZoomFactor)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVZoomRange").unwrap(), new)
    }
}
pub type AVCaptureVideoStabilizationMode = NSInteger;
pub type AVCaptureAutoFocusSystem = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeviceFormat(pub id);
impl std::ops::Deref for AVCaptureDeviceFormat {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeviceFormat {}
impl AVCaptureDeviceFormat {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceFormat").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDeviceFormat {}
impl PNSObject for AVCaptureDeviceFormat {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeviceFormat {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDeviceFormat, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeviceFormat").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDeviceFormat(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDeviceFormat")
        }
    }
}
impl IAVCaptureDeviceFormat for AVCaptureDeviceFormat {}
pub trait IAVCaptureDeviceFormat: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn isVideoStabilizationModeSupported_(
        &self,
        videoStabilizationMode: AVCaptureVideoStabilizationMode,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isVideoStabilizationModeSupported : videoStabilizationMode)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn formatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formatDescription)
    }
    unsafe fn videoSupportedFrameRateRanges(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoSupportedFrameRateRanges)
    }
    unsafe fn videoFieldOfView(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFieldOfView)
    }
    unsafe fn isVideoBinned(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoBinned)
    }
    unsafe fn isVideoStabilizationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoStabilizationSupported)
    }
    unsafe fn videoMaxZoomFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxZoomFactor)
    }
    unsafe fn videoZoomFactorUpscaleThreshold(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoZoomFactorUpscaleThreshold)
    }
    unsafe fn systemRecommendedVideoZoomRange(&self) -> AVZoomRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, systemRecommendedVideoZoomRange)
    }
    unsafe fn minExposureDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minExposureDuration)
    }
    unsafe fn maxExposureDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxExposureDuration)
    }
    unsafe fn systemRecommendedExposureBiasRange(&self) -> AVExposureBiasRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, systemRecommendedExposureBiasRange)
    }
    unsafe fn minISO(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minISO)
    }
    unsafe fn maxISO(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxISO)
    }
    unsafe fn isGlobalToneMappingSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isGlobalToneMappingSupported)
    }
    unsafe fn isVideoHDRSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoHDRSupported)
    }
    unsafe fn highResolutionStillImageDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, highResolutionStillImageDimensions)
    }
    unsafe fn isHighPhotoQualitySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isHighPhotoQualitySupported)
    }
    unsafe fn isHighestPhotoQualitySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isHighestPhotoQualitySupported)
    }
    unsafe fn autoFocusSystem(&self) -> AVCaptureAutoFocusSystem
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, autoFocusSystem)
    }
    unsafe fn supportedColorSpaces(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedColorSpaces)
    }
    unsafe fn videoMinZoomFactorForDepthDataDelivery(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMinZoomFactorForDepthDataDelivery)
    }
    unsafe fn videoMaxZoomFactorForDepthDataDelivery(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxZoomFactorForDepthDataDelivery)
    }
    unsafe fn supportedVideoZoomFactorsForDepthDataDelivery(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedVideoZoomFactorsForDepthDataDelivery)
    }
    unsafe fn supportedVideoZoomRangesForDepthDataDelivery(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedVideoZoomRangesForDepthDataDelivery)
    }
    unsafe fn zoomFactorsOutsideOfVideoZoomRangesForDepthDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, zoomFactorsOutsideOfVideoZoomRangesForDepthDeliverySupported)
    }
    unsafe fn supportedDepthDataFormats(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedDepthDataFormats)
    }
    unsafe fn unsupportedCaptureOutputClasses(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unsupportedCaptureOutputClasses)
    }
    unsafe fn supportedMaxPhotoDimensions(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedMaxPhotoDimensions)
    }
    unsafe fn secondaryNativeResolutionZoomFactors(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, secondaryNativeResolutionZoomFactors)
    }
    unsafe fn isAutoVideoFrameRateSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoVideoFrameRateSupported)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceFormat").unwrap(), new)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatDepthDataAdditions for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatDepthDataAdditions:
    Sized + std::ops::Deref
{
    unsafe fn isPortraitEffectsMatteStillImageDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectsMatteStillImageDeliverySupported)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatMultiCamAdditions for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatMultiCamAdditions:
    Sized + std::ops::Deref
{
    unsafe fn isMultiCamSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMultiCamSupported)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatSpatialVideoCapture for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatSpatialVideoCapture:
    Sized + std::ops::Deref
{
    unsafe fn isSpatialVideoCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSpatialVideoCaptureSupported)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatGeometricDistortionCorrection
    for AVCaptureDeviceFormat
{
}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatGeometricDistortionCorrection:
    Sized + std::ops::Deref
{
    unsafe fn geometricDistortionCorrectedVideoFieldOfView(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, geometricDistortionCorrectedVideoFieldOfView)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatCenterStage for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatCenterStage: Sized + std::ops::Deref {
    unsafe fn isCenterStageSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCenterStageSupported)
    }
    unsafe fn videoMinZoomFactorForCenterStage(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMinZoomFactorForCenterStage)
    }
    unsafe fn videoMaxZoomFactorForCenterStage(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxZoomFactorForCenterStage)
    }
    unsafe fn videoFrameRateRangeForCenterStage(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForCenterStage)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatPortraitEffect for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatPortraitEffect:
    Sized + std::ops::Deref
{
    unsafe fn isPortraitEffectSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectSupported)
    }
    unsafe fn videoFrameRateRangeForPortraitEffect(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForPortraitEffect)
    }
}
impl AVCaptureDevice_AVCaptureDeviceStudioLight for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceStudioLight: Sized + std::ops::Deref {
    unsafe fn isStudioLightActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStudioLightActive)
    }
    unsafe fn isStudioLightEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isStudioLightEnabled)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatStudioLight for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatStudioLight: Sized + std::ops::Deref {
    unsafe fn isStudioLightSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStudioLightSupported)
    }
    unsafe fn videoFrameRateRangeForStudioLight(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForStudioLight)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatReactionEffects for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatReactionEffects:
    Sized + std::ops::Deref
{
    unsafe fn reactionEffectsSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, reactionEffectsSupported)
    }
    unsafe fn videoFrameRateRangeForReactionEffectsInProgress(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForReactionEffectsInProgress)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatBackgroundReplacement for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatBackgroundReplacement:
    Sized + std::ops::Deref
{
    unsafe fn isBackgroundReplacementSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isBackgroundReplacementSupported)
    }
    unsafe fn videoFrameRateRangeForBackgroundReplacement(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForBackgroundReplacement)
    }
}
impl AVCaptureDevice_AVCaptureDeviceEdgeLight for AVCaptureDevice {}
pub trait AVCaptureDevice_AVCaptureDeviceEdgeLight: Sized + std::ops::Deref {
    unsafe fn isEdgeLightEnabled() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isEdgeLightEnabled)
    }
    unsafe fn isEdgeLightActive() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDevice").unwrap(), isEdgeLightActive)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatEdgeLight for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatEdgeLight: Sized + std::ops::Deref {
    unsafe fn isEdgeLightSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEdgeLightSupported)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatCinematicVideoSupport for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatCinematicVideoSupport:
    Sized + std::ops::Deref
{
    unsafe fn isCinematicVideoCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCinematicVideoCaptureSupported)
    }
    unsafe fn defaultSimulatedAperture(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, defaultSimulatedAperture)
    }
    unsafe fn minSimulatedAperture(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minSimulatedAperture)
    }
    unsafe fn maxSimulatedAperture(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxSimulatedAperture)
    }
    unsafe fn videoMinZoomFactorForCinematicVideo(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMinZoomFactorForCinematicVideo)
    }
    unsafe fn videoMaxZoomFactorForCinematicVideo(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxZoomFactorForCinematicVideo)
    }
    unsafe fn videoFrameRateRangeForCinematicVideo(&self) -> AVFrameRateRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFrameRateRangeForCinematicVideo)
    }
}
impl AVCaptureDeviceFormat_DynamicAspectRatio for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_DynamicAspectRatio: Sized + std::ops::Deref {
    unsafe fn videoFieldOfViewForAspectRatio_geometricDistortionCorrected_(
        &self,
        aspectRatio: NSString,
        geometricDistortionCorrected: BOOL,
    ) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, videoFieldOfViewForAspectRatio : aspectRatio, geometricDistortionCorrected : geometricDistortionCorrected)
    }
    unsafe fn supportedDynamicAspectRatios(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedDynamicAspectRatios)
    }
}
impl AVCaptureDeviceFormat_AVCaptureDeviceFormatSmartFraming for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_AVCaptureDeviceFormatSmartFraming: Sized + std::ops::Deref {
    unsafe fn isSmartFramingSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSmartFramingSupported)
    }
}
impl AVCaptureDeviceFormat_CameraLensSmudgeDetection for AVCaptureDeviceFormat {}
pub trait AVCaptureDeviceFormat_CameraLensSmudgeDetection: Sized + std::ops::Deref {
    unsafe fn isCameraLensSmudgeDetectionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraLensSmudgeDetectionSupported)
    }
}
impl AVCaptureDevice_CameraLensSmudgeDetection for AVCaptureDevice {}
pub trait AVCaptureDevice_CameraLensSmudgeDetection: Sized + std::ops::Deref {
    unsafe fn setCameraLensSmudgeDetectionEnabled_detectionInterval_(
        &self,
        cameraLensSmudgeDetectionEnabled: BOOL,
        detectionInterval: CMTime,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraLensSmudgeDetectionEnabled : cameraLensSmudgeDetectionEnabled, detectionInterval : detectionInterval)
    }
    unsafe fn isCameraLensSmudgeDetectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraLensSmudgeDetectionEnabled)
    }
    unsafe fn cameraLensSmudgeDetectionInterval(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraLensSmudgeDetectionInterval)
    }
    unsafe fn cameraLensSmudgeDetectionStatus(&self) -> AVCaptureCameraLensSmudgeDetectionStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraLensSmudgeDetectionStatus)
    }
}
pub type AVCaptureCameraLensSmudgeDetectionStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeviceInputSource(pub id);
impl std::ops::Deref for AVCaptureDeviceInputSource {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeviceInputSource {}
impl AVCaptureDeviceInputSource {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceInputSource").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDeviceInputSource {}
impl PNSObject for AVCaptureDeviceInputSource {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeviceInputSource {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDeviceInputSource, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeviceInputSource").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDeviceInputSource(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDeviceInputSource")
        }
    }
}
impl IAVCaptureDeviceInputSource for AVCaptureDeviceInputSource {}
pub trait IAVCaptureDeviceInputSource: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn inputSourceID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputSourceID)
    }
    unsafe fn localizedName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedName)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceInputSource").unwrap(), new)
    }
}
pub type AVCaptureSessionInterruptionReason = NSInteger;
pub type AVCaptureVideoOrientation = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSession(pub id);
impl std::ops::Deref for AVCaptureSession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSession {}
impl AVCaptureSession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSession").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureSession {}
impl PNSObject for AVCaptureSession {}
impl std::convert::TryFrom<NSObject> for AVCaptureSession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureSession, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSession").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureSession")
        }
    }
}
impl IAVCaptureSession for AVCaptureSession {}
pub trait IAVCaptureSession: Sized + std::ops::Deref {
    unsafe fn canSetSessionPreset_(&self, preset: NSString) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canSetSessionPreset : preset)
    }
    unsafe fn canAddInput_(&self, input: AVCaptureInput) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddInput : input)
    }
    unsafe fn addInput_(&self, input: AVCaptureInput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addInput : input)
    }
    unsafe fn removeInput_(&self, input: AVCaptureInput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeInput : input)
    }
    unsafe fn canAddOutput_(&self, output: AVCaptureOutput) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddOutput : output)
    }
    unsafe fn addOutput_(&self, output: AVCaptureOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addOutput : output)
    }
    unsafe fn removeOutput_(&self, output: AVCaptureOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeOutput : output)
    }
    unsafe fn addInputWithNoConnections_(&self, input: AVCaptureInput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addInputWithNoConnections : input)
    }
    unsafe fn addOutputWithNoConnections_(&self, output: AVCaptureOutput)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addOutputWithNoConnections : output)
    }
    unsafe fn canAddConnection_(&self, connection: AVCaptureConnection) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddConnection : connection)
    }
    unsafe fn addConnection_(&self, connection: AVCaptureConnection)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addConnection : connection)
    }
    unsafe fn removeConnection_(&self, connection: AVCaptureConnection)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeConnection : connection)
    }
    unsafe fn setControlsDelegate_queue_(
        &self,
        controlsDelegate: *mut u64,
        controlsDelegateCallbackQueue: NSObject,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setControlsDelegate : controlsDelegate, queue : controlsDelegateCallbackQueue)
    }
    unsafe fn canAddControl_(&self, control: AVCaptureControl) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, canAddControl : control)
    }
    unsafe fn addControl_(&self, control: AVCaptureControl)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, addControl : control)
    }
    unsafe fn removeControl_(&self, control: AVCaptureControl)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, removeControl : control)
    }
    unsafe fn beginConfiguration(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, beginConfiguration)
    }
    unsafe fn commitConfiguration(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, commitConfiguration)
    }
    unsafe fn startRunning(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, startRunning)
    }
    unsafe fn stopRunning(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopRunning)
    }
    unsafe fn runDeferredStartWhenNeeded(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, runDeferredStartWhenNeeded)
    }
    unsafe fn setDeferredStartDelegate_deferredStartDelegateCallbackQueue_(
        &self,
        deferredStartDelegate: *mut u64,
        deferredStartDelegateCallbackQueue: NSObject,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDeferredStartDelegate : deferredStartDelegate, deferredStartDelegateCallbackQueue : deferredStartDelegateCallbackQueue)
    }
    unsafe fn sessionPreset(&self) -> AVCaptureSessionPreset
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sessionPreset)
    }
    unsafe fn setSessionPreset_(&self, sessionPreset: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSessionPreset : sessionPreset)
    }
    unsafe fn inputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputs)
    }
    unsafe fn outputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputs)
    }
    unsafe fn connections(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, connections)
    }
    unsafe fn supportsControls(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportsControls)
    }
    unsafe fn maxControlsCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxControlsCount)
    }
    unsafe fn controlsDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, controlsDelegate)
    }
    unsafe fn controlsDelegateCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, controlsDelegateCallbackQueue)
    }
    unsafe fn controls(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, controls)
    }
    unsafe fn isRunning(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRunning)
    }
    unsafe fn isInterrupted(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isInterrupted)
    }
    unsafe fn isMultitaskingCameraAccessSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMultitaskingCameraAccessSupported)
    }
    unsafe fn isMultitaskingCameraAccessEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMultitaskingCameraAccessEnabled)
    }
    unsafe fn setMultitaskingCameraAccessEnabled_(&self, multitaskingCameraAccessEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMultitaskingCameraAccessEnabled : multitaskingCameraAccessEnabled)
    }
    unsafe fn usesApplicationAudioSession(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, usesApplicationAudioSession)
    }
    unsafe fn setUsesApplicationAudioSession_(&self, usesApplicationAudioSession: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setUsesApplicationAudioSession : usesApplicationAudioSession)
    }
    unsafe fn automaticallyConfiguresApplicationAudioSession(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyConfiguresApplicationAudioSession)
    }
    unsafe fn setAutomaticallyConfiguresApplicationAudioSession_(
        &self,
        automaticallyConfiguresApplicationAudioSession: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyConfiguresApplicationAudioSession : automaticallyConfiguresApplicationAudioSession)
    }
    unsafe fn configuresApplicationAudioSessionToMixWithOthers(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, configuresApplicationAudioSessionToMixWithOthers)
    }
    unsafe fn setConfiguresApplicationAudioSessionToMixWithOthers_(
        &self,
        configuresApplicationAudioSessionToMixWithOthers: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConfiguresApplicationAudioSessionToMixWithOthers : configuresApplicationAudioSessionToMixWithOthers)
    }
    unsafe fn configuresApplicationAudioSessionForBluetoothHighQualityRecording(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, configuresApplicationAudioSessionForBluetoothHighQualityRecording)
    }
    unsafe fn setConfiguresApplicationAudioSessionForBluetoothHighQualityRecording_(
        &self,
        configuresApplicationAudioSessionForBluetoothHighQualityRecording: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConfiguresApplicationAudioSessionForBluetoothHighQualityRecording : configuresApplicationAudioSessionForBluetoothHighQualityRecording)
    }
    unsafe fn automaticallyConfiguresCaptureDeviceForWideColor(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyConfiguresCaptureDeviceForWideColor)
    }
    unsafe fn setAutomaticallyConfiguresCaptureDeviceForWideColor_(
        &self,
        automaticallyConfiguresCaptureDeviceForWideColor: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyConfiguresCaptureDeviceForWideColor : automaticallyConfiguresCaptureDeviceForWideColor)
    }
    unsafe fn synchronizationClock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, synchronizationClock)
    }
    unsafe fn masterClock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, masterClock)
    }
    unsafe fn hardwareCost(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hardwareCost)
    }
    unsafe fn isManualDeferredStartSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isManualDeferredStartSupported)
    }
    unsafe fn automaticallyRunsDeferredStart(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyRunsDeferredStart)
    }
    unsafe fn setAutomaticallyRunsDeferredStart_(&self, automaticallyRunsDeferredStart: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyRunsDeferredStart : automaticallyRunsDeferredStart)
    }
    unsafe fn deferredStartDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deferredStartDelegate)
    }
    unsafe fn deferredStartDelegateCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deferredStartDelegateCallbackQueue)
    }
}
pub trait PAVCaptureSessionControlsDelegate: Sized + std::ops::Deref {
    unsafe fn sessionControlsDidBecomeActive_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionControlsDidBecomeActive : session)
    }
    unsafe fn sessionControlsWillEnterFullscreenAppearance_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionControlsWillEnterFullscreenAppearance : session)
    }
    unsafe fn sessionControlsWillExitFullscreenAppearance_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionControlsWillExitFullscreenAppearance : session)
    }
    unsafe fn sessionControlsDidBecomeInactive_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionControlsDidBecomeInactive : session)
    }
}
pub trait PAVCaptureSessionDeferredStartDelegate: Sized + std::ops::Deref {
    unsafe fn sessionWillRunDeferredStart_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionWillRunDeferredStart : session)
    }
    unsafe fn sessionDidRunDeferredStart_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, sessionDidRunDeferredStart : session)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureMultiCamSession(pub id);
impl std::ops::Deref for AVCaptureMultiCamSession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureMultiCamSession {}
impl AVCaptureMultiCamSession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMultiCamSession").unwrap(), alloc) })
    }
}
impl IAVCaptureSession for AVCaptureMultiCamSession {}
impl From<AVCaptureMultiCamSession> for AVCaptureSession {
    fn from(child: AVCaptureMultiCamSession) -> AVCaptureSession {
        AVCaptureSession(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureSession> for AVCaptureMultiCamSession {
    type Error = &'static str;
    fn try_from(parent: AVCaptureSession) -> Result<AVCaptureMultiCamSession, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureMultiCamSession").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureMultiCamSession(parent.0))
        } else {
            Err("This AVCaptureSession cannot be downcasted to AVCaptureMultiCamSession")
        }
    }
}
impl INSObject for AVCaptureMultiCamSession {}
impl PNSObject for AVCaptureMultiCamSession {}
impl IAVCaptureMultiCamSession for AVCaptureMultiCamSession {}
pub trait IAVCaptureMultiCamSession: Sized + std::ops::Deref {
    unsafe fn hardwareCost(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hardwareCost)
    }
    unsafe fn systemPressureCost(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, systemPressureCost)
    }
    unsafe fn isMultiCamSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMultiCamSession").unwrap(), isMultiCamSupported)
    }
}
pub type AVVideoFieldMode = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureConnection(pub id);
impl std::ops::Deref for AVCaptureConnection {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureConnection {}
impl AVCaptureConnection {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureConnection").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureConnection {}
impl PNSObject for AVCaptureConnection {}
impl std::convert::TryFrom<NSObject> for AVCaptureConnection {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureConnection, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureConnection").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureConnection(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureConnection")
        }
    }
}
impl IAVCaptureConnection for AVCaptureConnection {}
pub trait IAVCaptureConnection: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithInputPorts_output_(
        &self,
        ports: NSArray,
        output: AVCaptureOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithInputPorts : ports, output : output)
    }
    unsafe fn initWithInputPort_videoPreviewLayer_(
        &self,
        port: AVCaptureInputPort,
        layer: AVCaptureVideoPreviewLayer,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithInputPort : port, videoPreviewLayer : layer)
    }
    unsafe fn isVideoRotationAngleSupported_(&self, videoRotationAngle: CGFloat) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isVideoRotationAngleSupported : videoRotationAngle)
    }
    unsafe fn inputPorts(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, inputPorts)
    }
    unsafe fn output(&self) -> AVCaptureOutput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, output)
    }
    unsafe fn videoPreviewLayer(&self) -> AVCaptureVideoPreviewLayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoPreviewLayer)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn isActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isActive)
    }
    unsafe fn audioChannels(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioChannels)
    }
    unsafe fn isVideoMirroringSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoMirroringSupported)
    }
    unsafe fn isVideoMirrored(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoMirrored)
    }
    unsafe fn setVideoMirrored_(&self, videoMirrored: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoMirrored : videoMirrored)
    }
    unsafe fn automaticallyAdjustsVideoMirroring(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyAdjustsVideoMirroring)
    }
    unsafe fn setAutomaticallyAdjustsVideoMirroring_(
        &self,
        automaticallyAdjustsVideoMirroring: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyAdjustsVideoMirroring : automaticallyAdjustsVideoMirroring)
    }
    unsafe fn videoRotationAngle(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoRotationAngle)
    }
    unsafe fn setVideoRotationAngle_(&self, videoRotationAngle: CGFloat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoRotationAngle : videoRotationAngle)
    }
    unsafe fn isVideoOrientationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoOrientationSupported)
    }
    unsafe fn videoOrientation(&self) -> AVCaptureVideoOrientation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoOrientation)
    }
    unsafe fn setVideoOrientation_(&self, videoOrientation: AVCaptureVideoOrientation)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoOrientation : videoOrientation)
    }
    unsafe fn isVideoFieldModeSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoFieldModeSupported)
    }
    unsafe fn videoFieldMode(&self) -> AVVideoFieldMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoFieldMode)
    }
    unsafe fn setVideoFieldMode_(&self, videoFieldMode: AVVideoFieldMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoFieldMode : videoFieldMode)
    }
    unsafe fn isVideoMinFrameDurationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoMinFrameDurationSupported)
    }
    unsafe fn videoMinFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMinFrameDuration)
    }
    unsafe fn setVideoMinFrameDuration_(&self, videoMinFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoMinFrameDuration : videoMinFrameDuration)
    }
    unsafe fn isVideoMaxFrameDurationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoMaxFrameDurationSupported)
    }
    unsafe fn videoMaxFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxFrameDuration)
    }
    unsafe fn setVideoMaxFrameDuration_(&self, videoMaxFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoMaxFrameDuration : videoMaxFrameDuration)
    }
    unsafe fn videoMaxScaleAndCropFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMaxScaleAndCropFactor)
    }
    unsafe fn videoScaleAndCropFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoScaleAndCropFactor)
    }
    unsafe fn setVideoScaleAndCropFactor_(&self, videoScaleAndCropFactor: CGFloat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoScaleAndCropFactor : videoScaleAndCropFactor)
    }
    unsafe fn preferredVideoStabilizationMode(&self) -> AVCaptureVideoStabilizationMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredVideoStabilizationMode)
    }
    unsafe fn setPreferredVideoStabilizationMode_(
        &self,
        preferredVideoStabilizationMode: AVCaptureVideoStabilizationMode,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredVideoStabilizationMode : preferredVideoStabilizationMode)
    }
    unsafe fn activeVideoStabilizationMode(&self) -> AVCaptureVideoStabilizationMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeVideoStabilizationMode)
    }
    unsafe fn isVideoStabilizationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoStabilizationSupported)
    }
    unsafe fn isVideoStabilizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVideoStabilizationEnabled)
    }
    unsafe fn enablesVideoStabilizationWhenAvailable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enablesVideoStabilizationWhenAvailable)
    }
    unsafe fn setEnablesVideoStabilizationWhenAvailable_(
        &self,
        enablesVideoStabilizationWhenAvailable: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnablesVideoStabilizationWhenAvailable : enablesVideoStabilizationWhenAvailable)
    }
    unsafe fn isCameraIntrinsicMatrixDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraIntrinsicMatrixDeliverySupported)
    }
    unsafe fn isCameraIntrinsicMatrixDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraIntrinsicMatrixDeliveryEnabled)
    }
    unsafe fn setCameraIntrinsicMatrixDeliveryEnabled_(
        &self,
        cameraIntrinsicMatrixDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraIntrinsicMatrixDeliveryEnabled : cameraIntrinsicMatrixDeliveryEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureConnection").unwrap(), new)
    }
    unsafe fn connectionWithInputPorts_output_(
        ports: NSArray,
        output: AVCaptureOutput,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureConnection").unwrap(), connectionWithInputPorts : ports, output : output)
    }
    unsafe fn connectionWithInputPort_videoPreviewLayer_(
        port: AVCaptureInputPort,
        layer: AVCaptureVideoPreviewLayer,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureConnection").unwrap(), connectionWithInputPort : port, videoPreviewLayer : layer)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureAudioChannel(pub id);
impl std::ops::Deref for AVCaptureAudioChannel {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureAudioChannel {}
impl AVCaptureAudioChannel {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioChannel").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureAudioChannel {}
impl PNSObject for AVCaptureAudioChannel {}
impl std::convert::TryFrom<NSObject> for AVCaptureAudioChannel {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureAudioChannel, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureAudioChannel").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureAudioChannel(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureAudioChannel")
        }
    }
}
impl IAVCaptureAudioChannel for AVCaptureAudioChannel {}
pub trait IAVCaptureAudioChannel: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn averagePowerLevel(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, averagePowerLevel)
    }
    unsafe fn peakHoldLevel(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, peakHoldLevel)
    }
    unsafe fn volume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, volume)
    }
    unsafe fn setVolume_(&self, volume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolume : volume)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioChannel").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureOutput(pub id);
impl std::ops::Deref for AVCaptureOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureOutput {}
impl AVCaptureOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureOutput").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureOutput {}
impl PNSObject for AVCaptureOutput {}
impl std::convert::TryFrom<NSObject> for AVCaptureOutput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureOutput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureOutput")
        }
    }
}
impl IAVCaptureOutput for AVCaptureOutput {}
pub trait IAVCaptureOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn connectionWithMediaType_(&self, mediaType: NSString) -> AVCaptureConnection
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, connectionWithMediaType : mediaType)
    }
    unsafe fn transformedMetadataObjectForMetadataObject_connection_(
        &self,
        metadataObject: AVMetadataObject,
        connection: AVCaptureConnection,
    ) -> AVMetadataObject
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, transformedMetadataObjectForMetadataObject : metadataObject, connection : connection)
    }
    unsafe fn metadataOutputRectOfInterestForRect_(&self, rectInOutputCoordinates: CGRect) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataOutputRectOfInterestForRect : rectInOutputCoordinates)
    }
    unsafe fn rectForMetadataOutputRectOfInterest_(
        &self,
        rectInMetadataOutputCoordinates: CGRect,
    ) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, rectForMetadataOutputRectOfInterest : rectInMetadataOutputCoordinates)
    }
    unsafe fn connections(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, connections)
    }
    unsafe fn isDeferredStartSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDeferredStartSupported)
    }
    unsafe fn isDeferredStartEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDeferredStartEnabled)
    }
    unsafe fn setDeferredStartEnabled_(&self, deferredStartEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDeferredStartEnabled : deferredStartEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureOutput").unwrap(), new)
    }
}
pub type AVCaptureOutputDataDroppedReason = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureAudioDataOutput(pub id);
impl std::ops::Deref for AVCaptureAudioDataOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureAudioDataOutput {}
impl AVCaptureAudioDataOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioDataOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureAudioDataOutput {}
impl From<AVCaptureAudioDataOutput> for AVCaptureOutput {
    fn from(child: AVCaptureAudioDataOutput) -> AVCaptureOutput {
        AVCaptureOutput(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureAudioDataOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureAudioDataOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureAudioDataOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureAudioDataOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureAudioDataOutput")
        }
    }
}
impl INSObject for AVCaptureAudioDataOutput {}
impl PNSObject for AVCaptureAudioDataOutput {}
impl IAVCaptureAudioDataOutput for AVCaptureAudioDataOutput {}
pub trait IAVCaptureAudioDataOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setSampleBufferDelegate_queue_(
        &self,
        sampleBufferDelegate: *mut u64,
        sampleBufferCallbackQueue: NSObject,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSampleBufferDelegate : sampleBufferDelegate, queue : sampleBufferCallbackQueue)
    }
    unsafe fn recommendedAudioSettingsForAssetWriterWithOutputFileType_(
        &self,
        outputFileType: NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recommendedAudioSettingsForAssetWriterWithOutputFileType : outputFileType)
    }
    unsafe fn sampleBufferDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferDelegate)
    }
    unsafe fn sampleBufferCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferCallbackQueue)
    }
    unsafe fn audioSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioSettings)
    }
    unsafe fn setAudioSettings_(&self, audioSettings: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioSettings : audioSettings)
    }
    unsafe fn spatialAudioChannelLayoutTag(&self) -> AudioChannelLayoutTag
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, spatialAudioChannelLayoutTag)
    }
    unsafe fn setSpatialAudioChannelLayoutTag_(
        &self,
        spatialAudioChannelLayoutTag: AudioChannelLayoutTag,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSpatialAudioChannelLayoutTag : spatialAudioChannelLayoutTag)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioDataOutput").unwrap(), new)
    }
}
pub trait PAVCaptureAudioDataOutputSampleBufferDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutput_didOutputSampleBuffer_fromConnection_(
        &self,
        output: AVCaptureOutput,
        sampleBuffer: CMSampleBufferRef,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didOutputSampleBuffer : sampleBuffer, fromConnection : connection)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureAudioPreviewOutput(pub id);
impl std::ops::Deref for AVCaptureAudioPreviewOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureAudioPreviewOutput {}
impl AVCaptureAudioPreviewOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioPreviewOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureAudioPreviewOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureAudioPreviewOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureAudioPreviewOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureAudioPreviewOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureAudioPreviewOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureAudioPreviewOutput")
        }
    }
}
impl INSObject for AVCaptureAudioPreviewOutput {}
impl PNSObject for AVCaptureAudioPreviewOutput {}
impl IAVCaptureAudioPreviewOutput for AVCaptureAudioPreviewOutput {}
pub trait IAVCaptureAudioPreviewOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn outputDeviceUniqueID(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputDeviceUniqueID)
    }
    unsafe fn setOutputDeviceUniqueID_(&self, outputDeviceUniqueID: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputDeviceUniqueID : outputDeviceUniqueID)
    }
    unsafe fn volume(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, volume)
    }
    unsafe fn setVolume_(&self, volume: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVolume : volume)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioPreviewOutput").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureControl(pub id);
impl std::ops::Deref for AVCaptureControl {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureControl {}
impl AVCaptureControl {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureControl").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureControl {}
impl PNSObject for AVCaptureControl {}
impl std::convert::TryFrom<NSObject> for AVCaptureControl {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureControl, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureControl").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureControl(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureControl")
        }
    }
}
impl IAVCaptureControl for AVCaptureControl {}
pub trait IAVCaptureControl: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureControl").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDepthDataOutput(pub id);
impl std::ops::Deref for AVCaptureDepthDataOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDepthDataOutput {}
impl AVCaptureDepthDataOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDepthDataOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureDepthDataOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureDepthDataOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureDepthDataOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDepthDataOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDepthDataOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureDepthDataOutput")
        }
    }
}
impl INSObject for AVCaptureDepthDataOutput {}
impl PNSObject for AVCaptureDepthDataOutput {}
impl IAVCaptureDepthDataOutput for AVCaptureDepthDataOutput {}
pub trait IAVCaptureDepthDataOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setDelegate_callbackQueue_(&self, delegate: *mut u64, callbackQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, callbackQueue : callbackQueue)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateCallbackQueue)
    }
    unsafe fn alwaysDiscardsLateDepthData(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alwaysDiscardsLateDepthData)
    }
    unsafe fn setAlwaysDiscardsLateDepthData_(&self, alwaysDiscardsLateDepthData: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlwaysDiscardsLateDepthData : alwaysDiscardsLateDepthData)
    }
    unsafe fn isFilteringEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFilteringEnabled)
    }
    unsafe fn setFilteringEnabled_(&self, filteringEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFilteringEnabled : filteringEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDepthDataOutput").unwrap(), new)
    }
}
pub trait PAVCaptureDepthDataOutputDelegate: Sized + std::ops::Deref {
    unsafe fn depthDataOutput_didOutputDepthData_timestamp_connection_(
        &self,
        output: AVCaptureDepthDataOutput,
        depthData: AVDepthData,
        timestamp: CMTime,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, depthDataOutput : output, didOutputDepthData : depthData, timestamp : timestamp, connection : connection)
    }
    unsafe fn depthDataOutput_didDropDepthData_timestamp_connection_reason_(
        &self,
        output: AVCaptureDepthDataOutput,
        depthData: AVDepthData,
        timestamp: CMTime,
        connection: AVCaptureConnection,
        reason: AVCaptureOutputDataDroppedReason,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, depthDataOutput : output, didDropDepthData : depthData, timestamp : timestamp, connection : connection, reason : reason)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureFileOutput(pub id);
impl std::ops::Deref for AVCaptureFileOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureFileOutput {}
impl AVCaptureFileOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureFileOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureFileOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureFileOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureFileOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureFileOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureFileOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureFileOutput")
        }
    }
}
impl INSObject for AVCaptureFileOutput {}
impl PNSObject for AVCaptureFileOutput {}
impl IAVCaptureFileOutput for AVCaptureFileOutput {}
pub trait IAVCaptureFileOutput: Sized + std::ops::Deref {
    unsafe fn startRecordingToOutputFileURL_recordingDelegate_(
        &self,
        outputFileURL: NSURL,
        delegate: *mut u64,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startRecordingToOutputFileURL : outputFileURL, recordingDelegate : delegate)
    }
    unsafe fn stopRecording(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stopRecording)
    }
    unsafe fn pauseRecording(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pauseRecording)
    }
    unsafe fn resumeRecording(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resumeRecording)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn setDelegate_(&self, delegate: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate)
    }
    unsafe fn outputFileURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputFileURL)
    }
    unsafe fn isRecording(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRecording)
    }
    unsafe fn isRecordingPaused(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRecordingPaused)
    }
    unsafe fn recordedDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recordedDuration)
    }
    unsafe fn recordedFileSize(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recordedFileSize)
    }
    unsafe fn maxRecordedDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxRecordedDuration)
    }
    unsafe fn setMaxRecordedDuration_(&self, maxRecordedDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxRecordedDuration : maxRecordedDuration)
    }
    unsafe fn maxRecordedFileSize(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxRecordedFileSize)
    }
    unsafe fn setMaxRecordedFileSize_(&self, maxRecordedFileSize: i64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxRecordedFileSize : maxRecordedFileSize)
    }
    unsafe fn minFreeDiskSpaceLimit(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFreeDiskSpaceLimit)
    }
    unsafe fn setMinFreeDiskSpaceLimit_(&self, minFreeDiskSpaceLimit: i64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMinFreeDiskSpaceLimit : minFreeDiskSpaceLimit)
    }
}
pub trait PAVCaptureFileOutputRecordingDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutput_didStartRecordingToOutputFileAtURL_fromConnections_(
        &self,
        output: AVCaptureFileOutput,
        fileURL: NSURL,
        connections: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didStartRecordingToOutputFileAtURL : fileURL, fromConnections : connections)
    }
    unsafe fn captureOutput_didStartRecordingToOutputFileAtURL_startPTS_fromConnections_(
        &self,
        output: AVCaptureFileOutput,
        fileURL: NSURL,
        startPTS: CMTime,
        connections: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didStartRecordingToOutputFileAtURL : fileURL, startPTS : startPTS, fromConnections : connections)
    }
    unsafe fn captureOutput_didPauseRecordingToOutputFileAtURL_fromConnections_(
        &self,
        output: AVCaptureFileOutput,
        fileURL: NSURL,
        connections: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didPauseRecordingToOutputFileAtURL : fileURL, fromConnections : connections)
    }
    unsafe fn captureOutput_didResumeRecordingToOutputFileAtURL_fromConnections_(
        &self,
        output: AVCaptureFileOutput,
        fileURL: NSURL,
        connections: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didResumeRecordingToOutputFileAtURL : fileURL, fromConnections : connections)
    }
    unsafe fn captureOutput_willFinishRecordingToOutputFileAtURL_fromConnections_error_(
        &self,
        output: AVCaptureFileOutput,
        fileURL: NSURL,
        connections: NSArray,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, willFinishRecordingToOutputFileAtURL : fileURL, fromConnections : connections, error : error)
    }
    unsafe fn captureOutput_didFinishRecordingToOutputFileAtURL_fromConnections_error_(
        &self,
        output: AVCaptureFileOutput,
        outputFileURL: NSURL,
        connections: NSArray,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishRecordingToOutputFileAtURL : outputFileURL, fromConnections : connections, error : error)
    }
}
pub trait PAVCaptureFileOutputDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutputShouldProvideSampleAccurateRecordingStart_(
        &self,
        output: AVCaptureOutput,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutputShouldProvideSampleAccurateRecordingStart : output)
    }
    unsafe fn captureOutput_didOutputSampleBuffer_fromConnection_(
        &self,
        output: AVCaptureFileOutput,
        sampleBuffer: CMSampleBufferRef,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didOutputSampleBuffer : sampleBuffer, fromConnection : connection)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureMovieFileOutput(pub id);
impl std::ops::Deref for AVCaptureMovieFileOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureMovieFileOutput {}
impl AVCaptureMovieFileOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMovieFileOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureFileOutput for AVCaptureMovieFileOutput {}
impl From<AVCaptureMovieFileOutput> for AVCaptureFileOutput {
    fn from(child: AVCaptureMovieFileOutput) -> AVCaptureFileOutput {
        AVCaptureFileOutput(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureFileOutput> for AVCaptureMovieFileOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureFileOutput) -> Result<AVCaptureMovieFileOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureMovieFileOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureMovieFileOutput(parent.0))
        } else {
            Err("This AVCaptureFileOutput cannot be downcasted to AVCaptureMovieFileOutput")
        }
    }
}
impl IAVCaptureOutput for AVCaptureMovieFileOutput {}
impl INSObject for AVCaptureMovieFileOutput {}
impl PNSObject for AVCaptureMovieFileOutput {}
impl IAVCaptureMovieFileOutput for AVCaptureMovieFileOutput {}
pub trait IAVCaptureMovieFileOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn supportedOutputSettingsKeysForConnection_(
        &self,
        connection: AVCaptureConnection,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportedOutputSettingsKeysForConnection : connection)
    }
    unsafe fn outputSettingsForConnection_(&self, connection: AVCaptureConnection) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, outputSettingsForConnection : connection)
    }
    unsafe fn setOutputSettings_forConnection_(
        &self,
        outputSettings: NSDictionary,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputSettings : outputSettings, forConnection : connection)
    }
    unsafe fn recordsVideoOrientationAndMirroringChangesAsMetadataTrackForConnection_(
        &self,
        connection: AVCaptureConnection,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recordsVideoOrientationAndMirroringChangesAsMetadataTrackForConnection : connection)
    }
    unsafe fn setRecordsVideoOrientationAndMirroringChanges_asMetadataTrackForConnection_(
        &self,
        doRecordChanges: BOOL,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRecordsVideoOrientationAndMirroringChanges : doRecordChanges, asMetadataTrackForConnection : connection)
    }
    unsafe fn setPrimaryConstituentDeviceSwitchingBehaviorForRecording_restrictedSwitchingBehaviorConditions_(
        &self,
        switchingBehavior: AVCapturePrimaryConstituentDeviceSwitchingBehavior,
        restrictedSwitchingBehaviorConditions : AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPrimaryConstituentDeviceSwitchingBehaviorForRecording : switchingBehavior, restrictedSwitchingBehaviorConditions : restrictedSwitchingBehaviorConditions)
    }
    unsafe fn movieFragmentInterval(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, movieFragmentInterval)
    }
    unsafe fn setMovieFragmentInterval_(&self, movieFragmentInterval: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMovieFragmentInterval : movieFragmentInterval)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn availableVideoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableVideoCodecTypes)
    }
    unsafe fn isPrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled)
    }
    unsafe fn setPrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled_(
        &self,
        primaryConstituentDeviceSwitchingBehaviorForRecordingEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled : primaryConstituentDeviceSwitchingBehaviorForRecordingEnabled)
    }
    unsafe fn primaryConstituentDeviceSwitchingBehaviorForRecording(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceSwitchingBehavior
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryConstituentDeviceSwitchingBehaviorForRecording)
    }
    unsafe fn primaryConstituentDeviceRestrictedSwitchingBehaviorConditionsForRecording(
        &self,
    ) -> AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, primaryConstituentDeviceRestrictedSwitchingBehaviorConditionsForRecording)
    }
    unsafe fn isSpatialVideoCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSpatialVideoCaptureSupported)
    }
    unsafe fn isSpatialVideoCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isSpatialVideoCaptureEnabled)
    }
    unsafe fn setSpatialVideoCaptureEnabled_(&self, spatialVideoCaptureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSpatialVideoCaptureEnabled : spatialVideoCaptureEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMovieFileOutput").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureAudioFileOutput(pub id);
impl std::ops::Deref for AVCaptureAudioFileOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureAudioFileOutput {}
impl AVCaptureAudioFileOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioFileOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureFileOutput for AVCaptureAudioFileOutput {}
impl std::convert::TryFrom<AVCaptureFileOutput> for AVCaptureAudioFileOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureFileOutput) -> Result<AVCaptureAudioFileOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureAudioFileOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureAudioFileOutput(parent.0))
        } else {
            Err("This AVCaptureFileOutput cannot be downcasted to AVCaptureAudioFileOutput")
        }
    }
}
impl IAVCaptureOutput for AVCaptureAudioFileOutput {}
impl INSObject for AVCaptureAudioFileOutput {}
impl PNSObject for AVCaptureAudioFileOutput {}
impl IAVCaptureAudioFileOutput for AVCaptureAudioFileOutput {}
pub trait IAVCaptureAudioFileOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn startRecordingToOutputFileURL_outputFileType_recordingDelegate_(
        &self,
        outputFileURL: NSURL,
        fileType: NSString,
        delegate: *mut u64,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startRecordingToOutputFileURL : outputFileURL, outputFileType : fileType, recordingDelegate : delegate)
    }
    unsafe fn metadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn audioSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioSettings)
    }
    unsafe fn setAudioSettings_(&self, audioSettings: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAudioSettings : audioSettings)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioFileOutput").unwrap(), new)
    }
    unsafe fn availableOutputFileTypes() -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAudioFileOutput").unwrap(), availableOutputFileTypes)
    }
}
pub type AVMetadataObjectType = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataObject(pub id);
impl std::ops::Deref for AVMetadataObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataObject {}
impl AVMetadataObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataObject").unwrap(), alloc) })
    }
}
impl INSObject for AVMetadataObject {}
impl PNSObject for AVMetadataObject {}
impl std::convert::TryFrom<NSObject> for AVMetadataObject {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVMetadataObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataObject(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVMetadataObject")
        }
    }
}
impl IAVMetadataObject for AVMetadataObject {}
pub trait IAVMetadataObject: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn time(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, time)
    }
    unsafe fn duration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, duration)
    }
    unsafe fn bounds(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bounds)
    }
    unsafe fn type_(&self) -> AVMetadataObjectType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, type)
    }
    unsafe fn groupID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, groupID)
    }
    unsafe fn objectID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, objectID)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataObject").unwrap(), new)
    }
}
impl AVMetadataObject_AVMetadataObjectCinematicVideoSupport for AVMetadataObject {}
pub trait AVMetadataObject_AVMetadataObjectCinematicVideoSupport: Sized + std::ops::Deref {
    unsafe fn cinematicVideoFocusMode(&self) -> AVCaptureCinematicVideoFocusMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cinematicVideoFocusMode)
    }
    unsafe fn isFixedFocus(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFixedFocus)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataBodyObject(pub id);
impl std::ops::Deref for AVMetadataBodyObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataBodyObject {}
impl AVMetadataBodyObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataBodyObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataBodyObject {}
impl IAVMetadataObject for AVMetadataBodyObject {}
impl From<AVMetadataBodyObject> for AVMetadataObject {
    fn from(child: AVMetadataBodyObject) -> AVMetadataObject {
        AVMetadataObject(child.0)
    }
}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataBodyObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataObject) -> Result<AVMetadataBodyObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataBodyObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataBodyObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataBodyObject")
        }
    }
}
impl INSObject for AVMetadataBodyObject {}
impl PNSObject for AVMetadataBodyObject {}
impl IAVMetadataBodyObject for AVMetadataBodyObject {}
pub trait IAVMetadataBodyObject: Sized + std::ops::Deref {
    unsafe fn bodyID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bodyID)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataHumanBodyObject(pub id);
impl std::ops::Deref for AVMetadataHumanBodyObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataHumanBodyObject {}
impl AVMetadataHumanBodyObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataHumanBodyObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataHumanBodyObject {}
impl IAVMetadataBodyObject for AVMetadataHumanBodyObject {}
impl From<AVMetadataHumanBodyObject> for AVMetadataBodyObject {
    fn from(child: AVMetadataHumanBodyObject) -> AVMetadataBodyObject {
        AVMetadataBodyObject(child.0)
    }
}
impl std::convert::TryFrom<AVMetadataBodyObject> for AVMetadataHumanBodyObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataBodyObject) -> Result<AVMetadataHumanBodyObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataHumanBodyObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataHumanBodyObject(parent.0))
        } else {
            Err("This AVMetadataBodyObject cannot be downcasted to AVMetadataHumanBodyObject")
        }
    }
}
impl IAVMetadataObject for AVMetadataHumanBodyObject {}
impl INSObject for AVMetadataHumanBodyObject {}
impl PNSObject for AVMetadataHumanBodyObject {}
impl IAVMetadataHumanBodyObject for AVMetadataHumanBodyObject {}
pub trait IAVMetadataHumanBodyObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataHumanFullBodyObject(pub id);
impl std::ops::Deref for AVMetadataHumanFullBodyObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataHumanFullBodyObject {}
impl AVMetadataHumanFullBodyObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataHumanFullBodyObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataHumanFullBodyObject {}
impl IAVMetadataBodyObject for AVMetadataHumanFullBodyObject {}
impl std::convert::TryFrom<AVMetadataBodyObject> for AVMetadataHumanFullBodyObject {
    type Error = &'static str;
    fn try_from(
        parent: AVMetadataBodyObject,
    ) -> Result<AVMetadataHumanFullBodyObject, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataHumanFullBodyObject").unwrap())
        };
        if is_kind_of {
            Ok(AVMetadataHumanFullBodyObject(parent.0))
        } else {
            Err("This AVMetadataBodyObject cannot be downcasted to AVMetadataHumanFullBodyObject")
        }
    }
}
impl IAVMetadataObject for AVMetadataHumanFullBodyObject {}
impl INSObject for AVMetadataHumanFullBodyObject {}
impl PNSObject for AVMetadataHumanFullBodyObject {}
impl IAVMetadataHumanFullBodyObject for AVMetadataHumanFullBodyObject {}
pub trait IAVMetadataHumanFullBodyObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataCatHeadObject(pub id);
impl std::ops::Deref for AVMetadataCatHeadObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataCatHeadObject {}
impl AVMetadataCatHeadObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataCatHeadObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataCatHeadObject {}
impl IAVMetadataObject for AVMetadataCatHeadObject {}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataCatHeadObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataObject) -> Result<AVMetadataCatHeadObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataCatHeadObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataCatHeadObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataCatHeadObject")
        }
    }
}
impl INSObject for AVMetadataCatHeadObject {}
impl PNSObject for AVMetadataCatHeadObject {}
impl IAVMetadataCatHeadObject for AVMetadataCatHeadObject {}
pub trait IAVMetadataCatHeadObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataCatBodyObject(pub id);
impl std::ops::Deref for AVMetadataCatBodyObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataCatBodyObject {}
impl AVMetadataCatBodyObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataCatBodyObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataCatBodyObject {}
impl IAVMetadataBodyObject for AVMetadataCatBodyObject {}
impl std::convert::TryFrom<AVMetadataBodyObject> for AVMetadataCatBodyObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataBodyObject) -> Result<AVMetadataCatBodyObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataCatBodyObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataCatBodyObject(parent.0))
        } else {
            Err("This AVMetadataBodyObject cannot be downcasted to AVMetadataCatBodyObject")
        }
    }
}
impl IAVMetadataObject for AVMetadataCatBodyObject {}
impl INSObject for AVMetadataCatBodyObject {}
impl PNSObject for AVMetadataCatBodyObject {}
impl IAVMetadataCatBodyObject for AVMetadataCatBodyObject {}
pub trait IAVMetadataCatBodyObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataDogHeadObject(pub id);
impl std::ops::Deref for AVMetadataDogHeadObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataDogHeadObject {}
impl AVMetadataDogHeadObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataDogHeadObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataDogHeadObject {}
impl IAVMetadataObject for AVMetadataDogHeadObject {}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataDogHeadObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataObject) -> Result<AVMetadataDogHeadObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataDogHeadObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataDogHeadObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataDogHeadObject")
        }
    }
}
impl INSObject for AVMetadataDogHeadObject {}
impl PNSObject for AVMetadataDogHeadObject {}
impl IAVMetadataDogHeadObject for AVMetadataDogHeadObject {}
pub trait IAVMetadataDogHeadObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataDogBodyObject(pub id);
impl std::ops::Deref for AVMetadataDogBodyObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataDogBodyObject {}
impl AVMetadataDogBodyObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataDogBodyObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataDogBodyObject {}
impl IAVMetadataBodyObject for AVMetadataDogBodyObject {}
impl std::convert::TryFrom<AVMetadataBodyObject> for AVMetadataDogBodyObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataBodyObject) -> Result<AVMetadataDogBodyObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataDogBodyObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataDogBodyObject(parent.0))
        } else {
            Err("This AVMetadataBodyObject cannot be downcasted to AVMetadataDogBodyObject")
        }
    }
}
impl IAVMetadataObject for AVMetadataDogBodyObject {}
impl INSObject for AVMetadataDogBodyObject {}
impl PNSObject for AVMetadataDogBodyObject {}
impl IAVMetadataDogBodyObject for AVMetadataDogBodyObject {}
pub trait IAVMetadataDogBodyObject: Sized + std::ops::Deref {}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataSalientObject(pub id);
impl std::ops::Deref for AVMetadataSalientObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataSalientObject {}
impl AVMetadataSalientObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataSalientObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataSalientObject {}
impl IAVMetadataObject for AVMetadataSalientObject {}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataSalientObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataObject) -> Result<AVMetadataSalientObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataSalientObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataSalientObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataSalientObject")
        }
    }
}
impl INSObject for AVMetadataSalientObject {}
impl PNSObject for AVMetadataSalientObject {}
impl IAVMetadataSalientObject for AVMetadataSalientObject {}
pub trait IAVMetadataSalientObject: Sized + std::ops::Deref {
    unsafe fn objectID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, objectID)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataFaceObject(pub id);
impl std::ops::Deref for AVMetadataFaceObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataFaceObject {}
impl AVMetadataFaceObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataFaceObject").unwrap(), alloc) })
    }
}
impl PNSCopying for AVMetadataFaceObject {}
impl IAVMetadataObject for AVMetadataFaceObject {}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataFaceObject {
    type Error = &'static str;
    fn try_from(parent: AVMetadataObject) -> Result<AVMetadataFaceObject, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataFaceObject").unwrap()) };
        if is_kind_of {
            Ok(AVMetadataFaceObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataFaceObject")
        }
    }
}
impl INSObject for AVMetadataFaceObject {}
impl PNSObject for AVMetadataFaceObject {}
impl IAVMetadataFaceObject for AVMetadataFaceObject {}
pub trait IAVMetadataFaceObject: Sized + std::ops::Deref {
    unsafe fn faceID(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, faceID)
    }
    unsafe fn hasRollAngle(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasRollAngle)
    }
    unsafe fn rollAngle(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rollAngle)
    }
    unsafe fn hasYawAngle(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, hasYawAngle)
    }
    unsafe fn yawAngle(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, yawAngle)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVMetadataMachineReadableCodeObject(pub id);
impl std::ops::Deref for AVMetadataMachineReadableCodeObject {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVMetadataMachineReadableCodeObject {}
impl AVMetadataMachineReadableCodeObject {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVMetadataMachineReadableCodeObject").unwrap(), alloc) })
    }
}
impl IAVMetadataObject for AVMetadataMachineReadableCodeObject {}
impl std::convert::TryFrom<AVMetadataObject> for AVMetadataMachineReadableCodeObject {
    type Error = &'static str;
    fn try_from(
        parent: AVMetadataObject,
    ) -> Result<AVMetadataMachineReadableCodeObject, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVMetadataMachineReadableCodeObject").unwrap())
        };
        if is_kind_of {
            Ok(AVMetadataMachineReadableCodeObject(parent.0))
        } else {
            Err("This AVMetadataObject cannot be downcasted to AVMetadataMachineReadableCodeObject")
        }
    }
}
impl INSObject for AVMetadataMachineReadableCodeObject {}
impl PNSObject for AVMetadataMachineReadableCodeObject {}
impl IAVMetadataMachineReadableCodeObject for AVMetadataMachineReadableCodeObject {}
pub trait IAVMetadataMachineReadableCodeObject: Sized + std::ops::Deref {
    unsafe fn corners(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, corners)
    }
    unsafe fn stringValue(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stringValue)
    }
}
impl AVMetadataMachineReadableCodeObject_AVMetadataMachineReadableCodeDescriptor
    for AVMetadataMachineReadableCodeObject
{
}
pub trait AVMetadataMachineReadableCodeObject_AVMetadataMachineReadableCodeDescriptor:
    Sized + std::ops::Deref
{
    unsafe fn descriptor(&self) -> CIBarcodeDescriptor
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, descriptor)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureMetadataOutput(pub id);
impl std::ops::Deref for AVCaptureMetadataOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureMetadataOutput {}
impl AVCaptureMetadataOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMetadataOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureMetadataOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureMetadataOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureMetadataOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureMetadataOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureMetadataOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureMetadataOutput")
        }
    }
}
impl INSObject for AVCaptureMetadataOutput {}
impl PNSObject for AVCaptureMetadataOutput {}
impl IAVCaptureMetadataOutput for AVCaptureMetadataOutput {}
pub trait IAVCaptureMetadataOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setMetadataObjectsDelegate_queue_(
        &self,
        objectsDelegate: *mut u64,
        objectsCallbackQueue: NSObject,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadataObjectsDelegate : objectsDelegate, queue : objectsCallbackQueue)
    }
    unsafe fn metadataObjectsDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataObjectsDelegate)
    }
    unsafe fn metadataObjectsCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataObjectsCallbackQueue)
    }
    unsafe fn availableMetadataObjectTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableMetadataObjectTypes)
    }
    unsafe fn metadataObjectTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataObjectTypes)
    }
    unsafe fn setMetadataObjectTypes_(&self, metadataObjectTypes: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadataObjectTypes : metadataObjectTypes)
    }
    unsafe fn rectOfInterest(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rectOfInterest)
    }
    unsafe fn setRectOfInterest_(&self, rectOfInterest: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRectOfInterest : rectOfInterest)
    }
    unsafe fn requiredMetadataObjectTypesForCinematicVideoCapture(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiredMetadataObjectTypesForCinematicVideoCapture)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMetadataOutput").unwrap(), new)
    }
}
pub trait PAVCaptureMetadataOutputObjectsDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutput_didOutputMetadataObjects_fromConnection_(
        &self,
        output: AVCaptureOutput,
        metadataObjects: NSArray,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didOutputMetadataObjects : metadataObjects, fromConnection : connection)
    }
}
pub type AVSemanticSegmentationMatteType = NSString;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVSemanticSegmentationMatte(pub id);
impl std::ops::Deref for AVSemanticSegmentationMatte {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVSemanticSegmentationMatte {}
impl AVSemanticSegmentationMatte {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVSemanticSegmentationMatte").unwrap(), alloc) })
    }
}
impl INSObject for AVSemanticSegmentationMatte {}
impl PNSObject for AVSemanticSegmentationMatte {}
impl std::convert::TryFrom<NSObject> for AVSemanticSegmentationMatte {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVSemanticSegmentationMatte, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVSemanticSegmentationMatte").unwrap()) };
        if is_kind_of {
            Ok(AVSemanticSegmentationMatte(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVSemanticSegmentationMatte")
        }
    }
}
impl IAVSemanticSegmentationMatte for AVSemanticSegmentationMatte {}
pub trait IAVSemanticSegmentationMatte: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn semanticSegmentationMatteByApplyingExifOrientation_(
        &self,
        exifOrientation: CGImagePropertyOrientation,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, semanticSegmentationMatteByApplyingExifOrientation : exifOrientation)
    }
    unsafe fn semanticSegmentationMatteByReplacingSemanticSegmentationMatteWithPixelBuffer_error_(
        &self,
        pixelBuffer: CVPixelBufferRef,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, semanticSegmentationMatteByReplacingSemanticSegmentationMatteWithPixelBuffer : pixelBuffer, error : outError)
    }
    unsafe fn dictionaryRepresentationForAuxiliaryDataType_(
        &self,
        outAuxDataType: *mut NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dictionaryRepresentationForAuxiliaryDataType : outAuxDataType)
    }
    unsafe fn matteType(&self) -> AVSemanticSegmentationMatteType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, matteType)
    }
    unsafe fn pixelFormatType(&self) -> OSType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelFormatType)
    }
    unsafe fn mattingImage(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mattingImage)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSemanticSegmentationMatte").unwrap(), new)
    }
    unsafe fn semanticSegmentationMatteFromImageSourceAuxiliaryDataType_dictionaryRepresentation_error_(
        imageSourceAuxiliaryDataType: CFStringRef,
        imageSourceAuxiliaryDataInfoDictionary: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVSemanticSegmentationMatte").unwrap(), semanticSegmentationMatteFromImageSourceAuxiliaryDataType : imageSourceAuxiliaryDataType, dictionaryRepresentation : imageSourceAuxiliaryDataInfoDictionary, error : outError)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCapturePhotoOutput(pub id);
impl std::ops::Deref for AVCapturePhotoOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCapturePhotoOutput {}
impl AVCapturePhotoOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCapturePhotoOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCapturePhotoOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCapturePhotoOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCapturePhotoOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCapturePhotoOutput")
        }
    }
}
impl INSObject for AVCapturePhotoOutput {}
impl PNSObject for AVCapturePhotoOutput {}
impl IAVCapturePhotoOutput for AVCapturePhotoOutput {}
pub trait IAVCapturePhotoOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn capturePhotoWithSettings_delegate_(
        &self,
        settings: AVCapturePhotoSettings,
        delegate: *mut u64,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, capturePhotoWithSettings : settings, delegate : delegate)
    }
    unsafe fn setPreparedPhotoSettingsArray_completionHandler_(
        &self,
        preparedPhotoSettingsArray: NSArray,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreparedPhotoSettingsArray : preparedPhotoSettingsArray, completionHandler : completionHandler)
    }
    unsafe fn supportedPhotoPixelFormatTypesForFileType_(&self, fileType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportedPhotoPixelFormatTypesForFileType : fileType)
    }
    unsafe fn supportedPhotoCodecTypesForFileType_(&self, fileType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportedPhotoCodecTypesForFileType : fileType)
    }
    unsafe fn supportedRawPhotoCodecTypesForRawPhotoPixelFormatType_fileType_(
        &self,
        pixelFormatType: OSType,
        fileType: NSString,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportedRawPhotoCodecTypesForRawPhotoPixelFormatType : pixelFormatType, fileType : fileType)
    }
    unsafe fn supportedRawPhotoPixelFormatTypesForFileType_(&self, fileType: NSString) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, supportedRawPhotoPixelFormatTypesForFileType : fileType)
    }
    unsafe fn preparedPhotoSettingsArray(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preparedPhotoSettingsArray)
    }
    unsafe fn availablePhotoPixelFormatTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availablePhotoPixelFormatTypes)
    }
    unsafe fn availablePhotoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availablePhotoCodecTypes)
    }
    unsafe fn availableRawPhotoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableRawPhotoCodecTypes)
    }
    unsafe fn isAppleProRAWSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAppleProRAWSupported)
    }
    unsafe fn isAppleProRAWEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAppleProRAWEnabled)
    }
    unsafe fn setAppleProRAWEnabled_(&self, appleProRAWEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAppleProRAWEnabled : appleProRAWEnabled)
    }
    unsafe fn availableRawPhotoPixelFormatTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableRawPhotoPixelFormatTypes)
    }
    unsafe fn availablePhotoFileTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availablePhotoFileTypes)
    }
    unsafe fn availableRawPhotoFileTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableRawPhotoFileTypes)
    }
    unsafe fn maxPhotoQualityPrioritization(&self) -> AVCapturePhotoQualityPrioritization
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxPhotoQualityPrioritization)
    }
    unsafe fn setMaxPhotoQualityPrioritization_(
        &self,
        maxPhotoQualityPrioritization: AVCapturePhotoQualityPrioritization,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxPhotoQualityPrioritization : maxPhotoQualityPrioritization)
    }
    unsafe fn isFastCapturePrioritizationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFastCapturePrioritizationSupported)
    }
    unsafe fn setFastCapturePrioritizationSupported_(
        &self,
        fastCapturePrioritizationSupported: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFastCapturePrioritizationSupported : fastCapturePrioritizationSupported)
    }
    unsafe fn isFastCapturePrioritizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFastCapturePrioritizationEnabled)
    }
    unsafe fn setFastCapturePrioritizationEnabled_(&self, fastCapturePrioritizationEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFastCapturePrioritizationEnabled : fastCapturePrioritizationEnabled)
    }
    unsafe fn isAutoDeferredPhotoDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoDeferredPhotoDeliverySupported)
    }
    unsafe fn isAutoDeferredPhotoDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoDeferredPhotoDeliveryEnabled)
    }
    unsafe fn setAutoDeferredPhotoDeliveryEnabled_(&self, autoDeferredPhotoDeliveryEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoDeferredPhotoDeliveryEnabled : autoDeferredPhotoDeliveryEnabled)
    }
    unsafe fn isStillImageStabilizationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStillImageStabilizationSupported)
    }
    unsafe fn isStillImageStabilizationScene(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStillImageStabilizationScene)
    }
    unsafe fn isVirtualDeviceFusionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVirtualDeviceFusionSupported)
    }
    unsafe fn isDualCameraFusionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDualCameraFusionSupported)
    }
    unsafe fn isVirtualDeviceConstituentPhotoDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVirtualDeviceConstituentPhotoDeliverySupported)
    }
    unsafe fn isDualCameraDualPhotoDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDualCameraDualPhotoDeliverySupported)
    }
    unsafe fn isVirtualDeviceConstituentPhotoDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVirtualDeviceConstituentPhotoDeliveryEnabled)
    }
    unsafe fn setVirtualDeviceConstituentPhotoDeliveryEnabled_(
        &self,
        virtualDeviceConstituentPhotoDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVirtualDeviceConstituentPhotoDeliveryEnabled : virtualDeviceConstituentPhotoDeliveryEnabled)
    }
    unsafe fn isDualCameraDualPhotoDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDualCameraDualPhotoDeliveryEnabled)
    }
    unsafe fn setDualCameraDualPhotoDeliveryEnabled_(
        &self,
        dualCameraDualPhotoDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDualCameraDualPhotoDeliveryEnabled : dualCameraDualPhotoDeliveryEnabled)
    }
    unsafe fn isCameraCalibrationDataDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraCalibrationDataDeliverySupported)
    }
    unsafe fn supportedFlashModes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, supportedFlashModes)
    }
    unsafe fn isAutoRedEyeReductionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoRedEyeReductionSupported)
    }
    unsafe fn isFlashScene(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFlashScene)
    }
    unsafe fn photoSettingsForSceneMonitoring(&self) -> AVCapturePhotoSettings
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, photoSettingsForSceneMonitoring)
    }
    unsafe fn setPhotoSettingsForSceneMonitoring_(
        &self,
        photoSettingsForSceneMonitoring: AVCapturePhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPhotoSettingsForSceneMonitoring : photoSettingsForSceneMonitoring)
    }
    unsafe fn isHighResolutionCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isHighResolutionCaptureEnabled)
    }
    unsafe fn setHighResolutionCaptureEnabled_(&self, highResolutionCaptureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setHighResolutionCaptureEnabled : highResolutionCaptureEnabled)
    }
    unsafe fn maxPhotoDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxPhotoDimensions)
    }
    unsafe fn setMaxPhotoDimensions_(&self, maxPhotoDimensions: CMVideoDimensions)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxPhotoDimensions : maxPhotoDimensions)
    }
    unsafe fn maxBracketedCapturePhotoCount(&self) -> NSUInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxBracketedCapturePhotoCount)
    }
    unsafe fn isLensStabilizationDuringBracketedCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLensStabilizationDuringBracketedCaptureSupported)
    }
    unsafe fn isLivePhotoCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLivePhotoCaptureSupported)
    }
    unsafe fn isLivePhotoCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLivePhotoCaptureEnabled)
    }
    unsafe fn setLivePhotoCaptureEnabled_(&self, livePhotoCaptureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoCaptureEnabled : livePhotoCaptureEnabled)
    }
    unsafe fn isLivePhotoCaptureSuspended(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLivePhotoCaptureSuspended)
    }
    unsafe fn setLivePhotoCaptureSuspended_(&self, livePhotoCaptureSuspended: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoCaptureSuspended : livePhotoCaptureSuspended)
    }
    unsafe fn preservesLivePhotoCaptureSuspendedOnSessionStop(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preservesLivePhotoCaptureSuspendedOnSessionStop)
    }
    unsafe fn setPreservesLivePhotoCaptureSuspendedOnSessionStop_(
        &self,
        preservesLivePhotoCaptureSuspendedOnSessionStop: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreservesLivePhotoCaptureSuspendedOnSessionStop : preservesLivePhotoCaptureSuspendedOnSessionStop)
    }
    unsafe fn isLivePhotoAutoTrimmingEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLivePhotoAutoTrimmingEnabled)
    }
    unsafe fn setLivePhotoAutoTrimmingEnabled_(&self, livePhotoAutoTrimmingEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoAutoTrimmingEnabled : livePhotoAutoTrimmingEnabled)
    }
    unsafe fn availableLivePhotoVideoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableLivePhotoVideoCodecTypes)
    }
    unsafe fn isContentAwareDistortionCorrectionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isContentAwareDistortionCorrectionSupported)
    }
    unsafe fn isContentAwareDistortionCorrectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isContentAwareDistortionCorrectionEnabled)
    }
    unsafe fn setContentAwareDistortionCorrectionEnabled_(
        &self,
        contentAwareDistortionCorrectionEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setContentAwareDistortionCorrectionEnabled : contentAwareDistortionCorrectionEnabled)
    }
    unsafe fn isZeroShutterLagSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isZeroShutterLagSupported)
    }
    unsafe fn isZeroShutterLagEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isZeroShutterLagEnabled)
    }
    unsafe fn setZeroShutterLagEnabled_(&self, zeroShutterLagEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setZeroShutterLagEnabled : zeroShutterLagEnabled)
    }
    unsafe fn isResponsiveCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isResponsiveCaptureSupported)
    }
    unsafe fn isResponsiveCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isResponsiveCaptureEnabled)
    }
    unsafe fn setResponsiveCaptureEnabled_(&self, responsiveCaptureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setResponsiveCaptureEnabled : responsiveCaptureEnabled)
    }
    unsafe fn captureReadiness(&self) -> AVCapturePhotoOutputCaptureReadiness
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, captureReadiness)
    }
    unsafe fn isConstantColorSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConstantColorSupported)
    }
    unsafe fn isConstantColorEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConstantColorEnabled)
    }
    unsafe fn setConstantColorEnabled_(&self, constantColorEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConstantColorEnabled : constantColorEnabled)
    }
    unsafe fn isShutterSoundSuppressionSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isShutterSoundSuppressionSupported)
    }
    unsafe fn isCameraSensorOrientationCompensationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraSensorOrientationCompensationSupported)
    }
    unsafe fn isCameraSensorOrientationCompensationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraSensorOrientationCompensationEnabled)
    }
    unsafe fn setCameraSensorOrientationCompensationEnabled_(
        &self,
        cameraSensorOrientationCompensationEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraSensorOrientationCompensationEnabled : cameraSensorOrientationCompensationEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), new)
    }
    unsafe fn isBayerRAWPixelFormat_(pixelFormat: OSType) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), isBayerRAWPixelFormat : pixelFormat)
    }
    unsafe fn isAppleProRAWPixelFormat_(pixelFormat: OSType) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), isAppleProRAWPixelFormat : pixelFormat)
    }
    unsafe fn JPEGPhotoDataRepresentationForJPEGSampleBuffer_previewPhotoSampleBuffer_(
        JPEGSampleBuffer: CMSampleBufferRef,
        previewPhotoSampleBuffer: CMSampleBufferRef,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), JPEGPhotoDataRepresentationForJPEGSampleBuffer : JPEGSampleBuffer, previewPhotoSampleBuffer : previewPhotoSampleBuffer)
    }
    unsafe fn DNGPhotoDataRepresentationForRawSampleBuffer_previewPhotoSampleBuffer_(
        rawSampleBuffer: CMSampleBufferRef,
        previewPhotoSampleBuffer: CMSampleBufferRef,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutput").unwrap(), DNGPhotoDataRepresentationForRawSampleBuffer : rawSampleBuffer, previewPhotoSampleBuffer : previewPhotoSampleBuffer)
    }
}
pub type AVCapturePhotoQualityPrioritization = NSInteger;
pub type AVCapturePhotoOutputCaptureReadiness = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCapturePhotoOutputReadinessCoordinator(pub id);
impl std::ops::Deref for AVCapturePhotoOutputReadinessCoordinator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCapturePhotoOutputReadinessCoordinator {}
impl AVCapturePhotoOutputReadinessCoordinator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutputReadinessCoordinator").unwrap(), alloc) })
    }
}
impl INSObject for AVCapturePhotoOutputReadinessCoordinator {}
impl PNSObject for AVCapturePhotoOutputReadinessCoordinator {}
impl std::convert::TryFrom<NSObject> for AVCapturePhotoOutputReadinessCoordinator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCapturePhotoOutputReadinessCoordinator, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCapturePhotoOutputReadinessCoordinator").unwrap())
        };
        if is_kind_of {
            Ok(AVCapturePhotoOutputReadinessCoordinator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCapturePhotoOutputReadinessCoordinator")
        }
    }
}
impl IAVCapturePhotoOutputReadinessCoordinator for AVCapturePhotoOutputReadinessCoordinator {}
pub trait IAVCapturePhotoOutputReadinessCoordinator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithPhotoOutput_(&self, photoOutput: AVCapturePhotoOutput) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithPhotoOutput : photoOutput)
    }
    unsafe fn startTrackingCaptureRequestUsingPhotoSettings_(
        &self,
        settings: AVCapturePhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startTrackingCaptureRequestUsingPhotoSettings : settings)
    }
    unsafe fn stopTrackingCaptureRequestUsingPhotoSettingsUniqueID_(&self, settingsUniqueID: i64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, stopTrackingCaptureRequestUsingPhotoSettingsUniqueID : settingsUniqueID)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn setDelegate_(&self, delegate: *mut u64)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate)
    }
    unsafe fn captureReadiness(&self) -> AVCapturePhotoOutputCaptureReadiness
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, captureReadiness)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoOutputReadinessCoordinator").unwrap(), new)
    }
}
pub trait PAVCapturePhotoOutputReadinessCoordinatorDelegate: Sized + std::ops::Deref {
    unsafe fn readinessCoordinator_captureReadinessDidChange_(
        &self,
        coordinator: AVCapturePhotoOutputReadinessCoordinator,
        captureReadiness: AVCapturePhotoOutputCaptureReadiness,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, readinessCoordinator : coordinator, captureReadinessDidChange : captureReadiness)
    }
}
impl AVCapturePhotoOutput_AVCapturePhotoOutputDepthDataDeliverySupport for AVCapturePhotoOutput {}
pub trait AVCapturePhotoOutput_AVCapturePhotoOutputDepthDataDeliverySupport:
    Sized + std::ops::Deref
{
    unsafe fn isDepthDataDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDepthDataDeliverySupported)
    }
    unsafe fn isDepthDataDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDepthDataDeliveryEnabled)
    }
    unsafe fn setDepthDataDeliveryEnabled_(&self, depthDataDeliveryEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDepthDataDeliveryEnabled : depthDataDeliveryEnabled)
    }
    unsafe fn isPortraitEffectsMatteDeliverySupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectsMatteDeliverySupported)
    }
    unsafe fn isPortraitEffectsMatteDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectsMatteDeliveryEnabled)
    }
    unsafe fn setPortraitEffectsMatteDeliveryEnabled_(
        &self,
        portraitEffectsMatteDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPortraitEffectsMatteDeliveryEnabled : portraitEffectsMatteDeliveryEnabled)
    }
    unsafe fn availableSemanticSegmentationMatteTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableSemanticSegmentationMatteTypes)
    }
    unsafe fn enabledSemanticSegmentationMatteTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enabledSemanticSegmentationMatteTypes)
    }
    unsafe fn setEnabledSemanticSegmentationMatteTypes_(
        &self,
        enabledSemanticSegmentationMatteTypes: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabledSemanticSegmentationMatteTypes : enabledSemanticSegmentationMatteTypes)
    }
}
pub trait PAVCapturePhotoCaptureDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutput_willBeginCaptureForResolvedSettings_(
        &self,
        output: AVCapturePhotoOutput,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, willBeginCaptureForResolvedSettings : resolvedSettings)
    }
    unsafe fn captureOutput_willCapturePhotoForResolvedSettings_(
        &self,
        output: AVCapturePhotoOutput,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, willCapturePhotoForResolvedSettings : resolvedSettings)
    }
    unsafe fn captureOutput_didCapturePhotoForResolvedSettings_(
        &self,
        output: AVCapturePhotoOutput,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didCapturePhotoForResolvedSettings : resolvedSettings)
    }
    unsafe fn captureOutput_didFinishProcessingPhoto_error_(
        &self,
        output: AVCapturePhotoOutput,
        photo: AVCapturePhoto,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishProcessingPhoto : photo, error : error)
    }
    unsafe fn captureOutput_didFinishCapturingDeferredPhotoProxy_error_(
        &self,
        output: AVCapturePhotoOutput,
        deferredPhotoProxy: AVCaptureDeferredPhotoProxy,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishCapturingDeferredPhotoProxy : deferredPhotoProxy, error : error)
    }
    unsafe fn captureOutput_didFinishProcessingPhotoSampleBuffer_previewPhotoSampleBuffer_resolvedSettings_bracketSettings_error_(
        &self,
        output: AVCapturePhotoOutput,
        photoSampleBuffer: CMSampleBufferRef,
        previewPhotoSampleBuffer: CMSampleBufferRef,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
        bracketSettings: AVCaptureBracketedStillImageSettings,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishProcessingPhotoSampleBuffer : photoSampleBuffer, previewPhotoSampleBuffer : previewPhotoSampleBuffer, resolvedSettings : resolvedSettings, bracketSettings : bracketSettings, error : error)
    }
    unsafe fn captureOutput_didFinishProcessingRawPhotoSampleBuffer_previewPhotoSampleBuffer_resolvedSettings_bracketSettings_error_(
        &self,
        output: AVCapturePhotoOutput,
        rawSampleBuffer: CMSampleBufferRef,
        previewPhotoSampleBuffer: CMSampleBufferRef,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
        bracketSettings: AVCaptureBracketedStillImageSettings,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishProcessingRawPhotoSampleBuffer : rawSampleBuffer, previewPhotoSampleBuffer : previewPhotoSampleBuffer, resolvedSettings : resolvedSettings, bracketSettings : bracketSettings, error : error)
    }
    unsafe fn captureOutput_didFinishRecordingLivePhotoMovieForEventualFileAtURL_resolvedSettings_(
        &self,
        output: AVCapturePhotoOutput,
        outputFileURL: NSURL,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishRecordingLivePhotoMovieForEventualFileAtURL : outputFileURL, resolvedSettings : resolvedSettings)
    }
    unsafe fn captureOutput_didFinishProcessingLivePhotoToMovieFileAtURL_duration_photoDisplayTime_resolvedSettings_error_(
        &self,
        output: AVCapturePhotoOutput,
        outputFileURL: NSURL,
        duration: CMTime,
        photoDisplayTime: CMTime,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishProcessingLivePhotoToMovieFileAtURL : outputFileURL, duration : duration, photoDisplayTime : photoDisplayTime, resolvedSettings : resolvedSettings, error : error)
    }
    unsafe fn captureOutput_didFinishCaptureForResolvedSettings_error_(
        &self,
        output: AVCapturePhotoOutput,
        resolvedSettings: AVCaptureResolvedPhotoSettings,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didFinishCaptureForResolvedSettings : resolvedSettings, error : error)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCapturePhotoSettings(pub id);
impl std::ops::Deref for AVCapturePhotoSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCapturePhotoSettings {}
impl AVCapturePhotoSettings {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCapturePhotoSettings {}
impl INSObject for AVCapturePhotoSettings {}
impl PNSObject for AVCapturePhotoSettings {}
impl std::convert::TryFrom<NSObject> for AVCapturePhotoSettings {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCapturePhotoSettings, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap()) };
        if is_kind_of {
            Ok(AVCapturePhotoSettings(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCapturePhotoSettings")
        }
    }
}
impl IAVCapturePhotoSettings for AVCapturePhotoSettings {}
pub trait IAVCapturePhotoSettings: Sized + std::ops::Deref {
    unsafe fn uniqueID(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uniqueID)
    }
    unsafe fn format(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, format)
    }
    unsafe fn rawFileFormat(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawFileFormat)
    }
    unsafe fn setRawFileFormat_(&self, rawFileFormat: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRawFileFormat : rawFileFormat)
    }
    unsafe fn processedFileType(&self) -> AVFileType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, processedFileType)
    }
    unsafe fn rawPhotoPixelFormatType(&self) -> OSType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawPhotoPixelFormatType)
    }
    unsafe fn rawFileType(&self) -> AVFileType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawFileType)
    }
    unsafe fn flashMode(&self) -> AVCaptureFlashMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, flashMode)
    }
    unsafe fn setFlashMode_(&self, flashMode: AVCaptureFlashMode)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setFlashMode : flashMode)
    }
    unsafe fn isAutoRedEyeReductionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoRedEyeReductionEnabled)
    }
    unsafe fn setAutoRedEyeReductionEnabled_(&self, autoRedEyeReductionEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoRedEyeReductionEnabled : autoRedEyeReductionEnabled)
    }
    unsafe fn photoQualityPrioritization(&self) -> AVCapturePhotoQualityPrioritization
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, photoQualityPrioritization)
    }
    unsafe fn setPhotoQualityPrioritization_(
        &self,
        photoQualityPrioritization: AVCapturePhotoQualityPrioritization,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPhotoQualityPrioritization : photoQualityPrioritization)
    }
    unsafe fn isAutoStillImageStabilizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoStillImageStabilizationEnabled)
    }
    unsafe fn setAutoStillImageStabilizationEnabled_(
        &self,
        autoStillImageStabilizationEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoStillImageStabilizationEnabled : autoStillImageStabilizationEnabled)
    }
    unsafe fn isAutoVirtualDeviceFusionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoVirtualDeviceFusionEnabled)
    }
    unsafe fn setAutoVirtualDeviceFusionEnabled_(&self, autoVirtualDeviceFusionEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoVirtualDeviceFusionEnabled : autoVirtualDeviceFusionEnabled)
    }
    unsafe fn isAutoDualCameraFusionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoDualCameraFusionEnabled)
    }
    unsafe fn setAutoDualCameraFusionEnabled_(&self, autoDualCameraFusionEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoDualCameraFusionEnabled : autoDualCameraFusionEnabled)
    }
    unsafe fn virtualDeviceConstituentPhotoDeliveryEnabledDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, virtualDeviceConstituentPhotoDeliveryEnabledDevices)
    }
    unsafe fn setVirtualDeviceConstituentPhotoDeliveryEnabledDevices_(
        &self,
        virtualDeviceConstituentPhotoDeliveryEnabledDevices: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVirtualDeviceConstituentPhotoDeliveryEnabledDevices : virtualDeviceConstituentPhotoDeliveryEnabledDevices)
    }
    unsafe fn isDualCameraDualPhotoDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDualCameraDualPhotoDeliveryEnabled)
    }
    unsafe fn setDualCameraDualPhotoDeliveryEnabled_(
        &self,
        dualCameraDualPhotoDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDualCameraDualPhotoDeliveryEnabled : dualCameraDualPhotoDeliveryEnabled)
    }
    unsafe fn isHighResolutionPhotoEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isHighResolutionPhotoEnabled)
    }
    unsafe fn setHighResolutionPhotoEnabled_(&self, highResolutionPhotoEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setHighResolutionPhotoEnabled : highResolutionPhotoEnabled)
    }
    unsafe fn maxPhotoDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxPhotoDimensions)
    }
    unsafe fn setMaxPhotoDimensions_(&self, maxPhotoDimensions: CMVideoDimensions)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMaxPhotoDimensions : maxPhotoDimensions)
    }
    unsafe fn isDepthDataDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDepthDataDeliveryEnabled)
    }
    unsafe fn setDepthDataDeliveryEnabled_(&self, depthDataDeliveryEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDepthDataDeliveryEnabled : depthDataDeliveryEnabled)
    }
    unsafe fn embedsDepthDataInPhoto(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embedsDepthDataInPhoto)
    }
    unsafe fn setEmbedsDepthDataInPhoto_(&self, embedsDepthDataInPhoto: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEmbedsDepthDataInPhoto : embedsDepthDataInPhoto)
    }
    unsafe fn isDepthDataFiltered(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDepthDataFiltered)
    }
    unsafe fn setDepthDataFiltered_(&self, depthDataFiltered: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDepthDataFiltered : depthDataFiltered)
    }
    unsafe fn isCameraCalibrationDataDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraCalibrationDataDeliveryEnabled)
    }
    unsafe fn setCameraCalibrationDataDeliveryEnabled_(
        &self,
        cameraCalibrationDataDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraCalibrationDataDeliveryEnabled : cameraCalibrationDataDeliveryEnabled)
    }
    unsafe fn isPortraitEffectsMatteDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPortraitEffectsMatteDeliveryEnabled)
    }
    unsafe fn setPortraitEffectsMatteDeliveryEnabled_(
        &self,
        portraitEffectsMatteDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPortraitEffectsMatteDeliveryEnabled : portraitEffectsMatteDeliveryEnabled)
    }
    unsafe fn embedsPortraitEffectsMatteInPhoto(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embedsPortraitEffectsMatteInPhoto)
    }
    unsafe fn setEmbedsPortraitEffectsMatteInPhoto_(&self, embedsPortraitEffectsMatteInPhoto: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEmbedsPortraitEffectsMatteInPhoto : embedsPortraitEffectsMatteInPhoto)
    }
    unsafe fn enabledSemanticSegmentationMatteTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, enabledSemanticSegmentationMatteTypes)
    }
    unsafe fn setEnabledSemanticSegmentationMatteTypes_(
        &self,
        enabledSemanticSegmentationMatteTypes: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabledSemanticSegmentationMatteTypes : enabledSemanticSegmentationMatteTypes)
    }
    unsafe fn embedsSemanticSegmentationMattesInPhoto(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embedsSemanticSegmentationMattesInPhoto)
    }
    unsafe fn setEmbedsSemanticSegmentationMattesInPhoto_(
        &self,
        embedsSemanticSegmentationMattesInPhoto: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEmbedsSemanticSegmentationMattesInPhoto : embedsSemanticSegmentationMattesInPhoto)
    }
    unsafe fn metadata(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn setMetadata_(&self, metadata: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMetadata : metadata)
    }
    unsafe fn livePhotoMovieFileURL(&self) -> NSURL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, livePhotoMovieFileURL)
    }
    unsafe fn setLivePhotoMovieFileURL_(&self, livePhotoMovieFileURL: NSURL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoMovieFileURL : livePhotoMovieFileURL)
    }
    unsafe fn livePhotoVideoCodecType(&self) -> AVVideoCodecType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, livePhotoVideoCodecType)
    }
    unsafe fn setLivePhotoVideoCodecType_(&self, livePhotoVideoCodecType: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoVideoCodecType : livePhotoVideoCodecType)
    }
    unsafe fn livePhotoMovieMetadata(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, livePhotoMovieMetadata)
    }
    unsafe fn setLivePhotoMovieMetadata_(&self, livePhotoMovieMetadata: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLivePhotoMovieMetadata : livePhotoMovieMetadata)
    }
    unsafe fn availablePreviewPhotoPixelFormatTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availablePreviewPhotoPixelFormatTypes)
    }
    unsafe fn previewPhotoFormat(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewPhotoFormat)
    }
    unsafe fn setPreviewPhotoFormat_(&self, previewPhotoFormat: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreviewPhotoFormat : previewPhotoFormat)
    }
    unsafe fn availableEmbeddedThumbnailPhotoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableEmbeddedThumbnailPhotoCodecTypes)
    }
    unsafe fn embeddedThumbnailPhotoFormat(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embeddedThumbnailPhotoFormat)
    }
    unsafe fn setEmbeddedThumbnailPhotoFormat_(&self, embeddedThumbnailPhotoFormat: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEmbeddedThumbnailPhotoFormat : embeddedThumbnailPhotoFormat)
    }
    unsafe fn availableRawEmbeddedThumbnailPhotoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableRawEmbeddedThumbnailPhotoCodecTypes)
    }
    unsafe fn rawEmbeddedThumbnailPhotoFormat(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawEmbeddedThumbnailPhotoFormat)
    }
    unsafe fn setRawEmbeddedThumbnailPhotoFormat_(
        &self,
        rawEmbeddedThumbnailPhotoFormat: NSDictionary,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRawEmbeddedThumbnailPhotoFormat : rawEmbeddedThumbnailPhotoFormat)
    }
    unsafe fn isAutoContentAwareDistortionCorrectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isAutoContentAwareDistortionCorrectionEnabled)
    }
    unsafe fn setAutoContentAwareDistortionCorrectionEnabled_(
        &self,
        autoContentAwareDistortionCorrectionEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutoContentAwareDistortionCorrectionEnabled : autoContentAwareDistortionCorrectionEnabled)
    }
    unsafe fn isConstantColorEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConstantColorEnabled)
    }
    unsafe fn setConstantColorEnabled_(&self, constantColorEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConstantColorEnabled : constantColorEnabled)
    }
    unsafe fn isConstantColorFallbackPhotoDeliveryEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConstantColorFallbackPhotoDeliveryEnabled)
    }
    unsafe fn setConstantColorFallbackPhotoDeliveryEnabled_(
        &self,
        constantColorFallbackPhotoDeliveryEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setConstantColorFallbackPhotoDeliveryEnabled : constantColorFallbackPhotoDeliveryEnabled)
    }
    unsafe fn isShutterSoundSuppressionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isShutterSoundSuppressionEnabled)
    }
    unsafe fn setShutterSoundSuppressionEnabled_(&self, shutterSoundSuppressionEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setShutterSoundSuppressionEnabled : shutterSoundSuppressionEnabled)
    }
    unsafe fn photoSettings() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettings)
    }
    unsafe fn photoSettingsWithFormat_(format: NSDictionary) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettingsWithFormat : format)
    }
    unsafe fn photoSettingsWithRawPixelFormatType_(rawPixelFormatType: OSType) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettingsWithRawPixelFormatType : rawPixelFormatType)
    }
    unsafe fn photoSettingsWithRawPixelFormatType_processedFormat_(
        rawPixelFormatType: OSType,
        processedFormat: NSDictionary,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettingsWithRawPixelFormatType : rawPixelFormatType, processedFormat : processedFormat)
    }
    unsafe fn photoSettingsWithRawPixelFormatType_rawFileType_processedFormat_processedFileType_(
        rawPixelFormatType: OSType,
        rawFileType: NSString,
        processedFormat: NSDictionary,
        processedFileType: NSString,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettingsWithRawPixelFormatType : rawPixelFormatType, rawFileType : rawFileType, processedFormat : processedFormat, processedFileType : processedFileType)
    }
    unsafe fn photoSettingsFromPhotoSettings_(photoSettings: AVCapturePhotoSettings) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoSettings").unwrap(), photoSettingsFromPhotoSettings : photoSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCapturePhotoBracketSettings(pub id);
impl std::ops::Deref for AVCapturePhotoBracketSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCapturePhotoBracketSettings {}
impl AVCapturePhotoBracketSettings {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoBracketSettings").unwrap(), alloc) })
    }
}
impl IAVCapturePhotoSettings for AVCapturePhotoBracketSettings {}
impl PNSCopying for AVCapturePhotoBracketSettings {}
impl From<AVCapturePhotoBracketSettings> for AVCapturePhotoSettings {
    fn from(child: AVCapturePhotoBracketSettings) -> AVCapturePhotoSettings {
        AVCapturePhotoSettings(child.0)
    }
}
impl std::convert::TryFrom<AVCapturePhotoSettings> for AVCapturePhotoBracketSettings {
    type Error = &'static str;
    fn try_from(
        parent: AVCapturePhotoSettings,
    ) -> Result<AVCapturePhotoBracketSettings, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCapturePhotoBracketSettings").unwrap())
        };
        if is_kind_of {
            Ok(AVCapturePhotoBracketSettings(parent.0))
        } else {
            Err("This AVCapturePhotoSettings cannot be downcasted to AVCapturePhotoBracketSettings")
        }
    }
}
impl INSObject for AVCapturePhotoBracketSettings {}
impl PNSObject for AVCapturePhotoBracketSettings {}
impl IAVCapturePhotoBracketSettings for AVCapturePhotoBracketSettings {}
pub trait IAVCapturePhotoBracketSettings: Sized + std::ops::Deref {
    unsafe fn bracketedSettings(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bracketedSettings)
    }
    unsafe fn isLensStabilizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLensStabilizationEnabled)
    }
    unsafe fn setLensStabilizationEnabled_(&self, lensStabilizationEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLensStabilizationEnabled : lensStabilizationEnabled)
    }
    unsafe fn photoBracketSettingsWithRawPixelFormatType_processedFormat_bracketedSettings_(
        rawPixelFormatType: OSType,
        processedFormat: NSDictionary,
        bracketedSettings: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoBracketSettings").unwrap(), photoBracketSettingsWithRawPixelFormatType : rawPixelFormatType, processedFormat : processedFormat, bracketedSettings : bracketedSettings)
    }
    unsafe fn photoBracketSettingsWithRawPixelFormatType_rawFileType_processedFormat_processedFileType_bracketedSettings_(
        rawPixelFormatType: OSType,
        rawFileType: NSString,
        processedFormat: NSDictionary,
        processedFileType: NSString,
        bracketedSettings: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhotoBracketSettings").unwrap(), photoBracketSettingsWithRawPixelFormatType : rawPixelFormatType, rawFileType : rawFileType, processedFormat : processedFormat, processedFileType : processedFileType, bracketedSettings : bracketedSettings)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureResolvedPhotoSettings(pub id);
impl std::ops::Deref for AVCaptureResolvedPhotoSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureResolvedPhotoSettings {}
impl AVCaptureResolvedPhotoSettings {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureResolvedPhotoSettings").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureResolvedPhotoSettings {}
impl PNSObject for AVCaptureResolvedPhotoSettings {}
impl std::convert::TryFrom<NSObject> for AVCaptureResolvedPhotoSettings {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureResolvedPhotoSettings, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureResolvedPhotoSettings").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureResolvedPhotoSettings(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureResolvedPhotoSettings")
        }
    }
}
impl IAVCaptureResolvedPhotoSettings for AVCaptureResolvedPhotoSettings {}
pub trait IAVCaptureResolvedPhotoSettings: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn dimensionsForSemanticSegmentationMatteOfType_(
        &self,
        semanticSegmentationMatteType: NSString,
    ) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dimensionsForSemanticSegmentationMatteOfType : semanticSegmentationMatteType)
    }
    unsafe fn uniqueID(&self) -> i64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uniqueID)
    }
    unsafe fn photoDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, photoDimensions)
    }
    unsafe fn rawPhotoDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawPhotoDimensions)
    }
    unsafe fn previewDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewDimensions)
    }
    unsafe fn embeddedThumbnailDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embeddedThumbnailDimensions)
    }
    unsafe fn rawEmbeddedThumbnailDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, rawEmbeddedThumbnailDimensions)
    }
    unsafe fn portraitEffectsMatteDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, portraitEffectsMatteDimensions)
    }
    unsafe fn livePhotoMovieDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, livePhotoMovieDimensions)
    }
    unsafe fn isFlashEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFlashEnabled)
    }
    unsafe fn isRedEyeReductionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRedEyeReductionEnabled)
    }
    unsafe fn deferredPhotoProxyDimensions(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deferredPhotoProxyDimensions)
    }
    unsafe fn isStillImageStabilizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStillImageStabilizationEnabled)
    }
    unsafe fn isVirtualDeviceFusionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isVirtualDeviceFusionEnabled)
    }
    unsafe fn isDualCameraFusionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDualCameraFusionEnabled)
    }
    unsafe fn expectedPhotoCount(&self) -> NSUInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, expectedPhotoCount)
    }
    unsafe fn photoProcessingTimeRange(&self) -> CMTimeRange
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, photoProcessingTimeRange)
    }
    unsafe fn isContentAwareDistortionCorrectionEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isContentAwareDistortionCorrectionEnabled)
    }
    unsafe fn isFastCapturePrioritizationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isFastCapturePrioritizationEnabled)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureResolvedPhotoSettings").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCapturePhoto(pub id);
impl std::ops::Deref for AVCapturePhoto {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCapturePhoto {}
impl AVCapturePhoto {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhoto").unwrap(), alloc) })
    }
}
impl INSObject for AVCapturePhoto {}
impl PNSObject for AVCapturePhoto {}
impl std::convert::TryFrom<NSObject> for AVCapturePhoto {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCapturePhoto, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCapturePhoto").unwrap()) };
        if is_kind_of {
            Ok(AVCapturePhoto(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCapturePhoto")
        }
    }
}
impl IAVCapturePhoto for AVCapturePhoto {}
pub trait IAVCapturePhoto: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn semanticSegmentationMatteForType_(
        &self,
        semanticSegmentationMatteType: NSString,
    ) -> AVSemanticSegmentationMatte
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, semanticSegmentationMatteForType : semanticSegmentationMatteType)
    }
    unsafe fn timestamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timestamp)
    }
    unsafe fn isRawPhoto(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isRawPhoto)
    }
    unsafe fn pixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelBuffer)
    }
    unsafe fn previewPixelBuffer(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewPixelBuffer)
    }
    unsafe fn embeddedThumbnailPhotoFormat(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, embeddedThumbnailPhotoFormat)
    }
    unsafe fn depthData(&self) -> AVDepthData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthData)
    }
    unsafe fn portraitEffectsMatte(&self) -> AVPortraitEffectsMatte
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, portraitEffectsMatte)
    }
    unsafe fn metadata(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadata)
    }
    unsafe fn cameraCalibrationData(&self) -> AVCameraCalibrationData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraCalibrationData)
    }
    unsafe fn resolvedSettings(&self) -> AVCaptureResolvedPhotoSettings
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resolvedSettings)
    }
    unsafe fn photoCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, photoCount)
    }
    unsafe fn sourceDeviceType(&self) -> AVCaptureDeviceType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceDeviceType)
    }
    unsafe fn constantColorConfidenceMap(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, constantColorConfidenceMap)
    }
    unsafe fn constantColorCenterWeightedMeanConfidenceLevel(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, constantColorCenterWeightedMeanConfidenceLevel)
    }
    unsafe fn isConstantColorFallbackPhoto(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConstantColorFallbackPhoto)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCapturePhoto").unwrap(), new)
    }
}
impl AVCapturePhoto_AVCapturePhotoConversions for AVCapturePhoto {}
pub trait AVCapturePhoto_AVCapturePhotoConversions: Sized + std::ops::Deref {
    unsafe fn fileDataRepresentation(&self) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, fileDataRepresentation)
    }
    unsafe fn fileDataRepresentationWithCustomizer_(&self, customizer: *mut u64) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, fileDataRepresentationWithCustomizer : customizer)
    }
    unsafe fn fileDataRepresentationWithReplacementMetadata_replacementEmbeddedThumbnailPhotoFormat_replacementEmbeddedThumbnailPixelBuffer_replacementDepthData_(
        &self,
        replacementMetadata: NSDictionary,
        replacementEmbeddedThumbnailPhotoFormat: NSDictionary,
        replacementEmbeddedThumbnailPixelBuffer: CVPixelBufferRef,
        replacementDepthData: AVDepthData,
    ) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, fileDataRepresentationWithReplacementMetadata : replacementMetadata, replacementEmbeddedThumbnailPhotoFormat : replacementEmbeddedThumbnailPhotoFormat, replacementEmbeddedThumbnailPixelBuffer : replacementEmbeddedThumbnailPixelBuffer, replacementDepthData : replacementDepthData)
    }
    unsafe fn CGImageRepresentation(&self) -> CGImageRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, CGImageRepresentation)
    }
    unsafe fn previewCGImageRepresentation(&self) -> CGImageRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewCGImageRepresentation)
    }
}
pub type AVCaptureLensStabilizationStatus = NSInteger;
impl AVCapturePhoto_AVCapturePhotoBracketedCapture for AVCapturePhoto {}
pub trait AVCapturePhoto_AVCapturePhotoBracketedCapture: Sized + std::ops::Deref {
    unsafe fn bracketSettings(&self) -> AVCaptureBracketedStillImageSettings
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bracketSettings)
    }
    unsafe fn sequenceCount(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sequenceCount)
    }
    unsafe fn lensStabilizationStatus(&self) -> AVCaptureLensStabilizationStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, lensStabilizationStatus)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeferredPhotoProxy(pub id);
impl std::ops::Deref for AVCaptureDeferredPhotoProxy {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeferredPhotoProxy {}
impl AVCaptureDeferredPhotoProxy {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeferredPhotoProxy").unwrap(), alloc) })
    }
}
impl IAVCapturePhoto for AVCaptureDeferredPhotoProxy {}
impl From<AVCaptureDeferredPhotoProxy> for AVCapturePhoto {
    fn from(child: AVCaptureDeferredPhotoProxy) -> AVCapturePhoto {
        AVCapturePhoto(child.0)
    }
}
impl std::convert::TryFrom<AVCapturePhoto> for AVCaptureDeferredPhotoProxy {
    type Error = &'static str;
    fn try_from(parent: AVCapturePhoto) -> Result<AVCaptureDeferredPhotoProxy, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeferredPhotoProxy").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDeferredPhotoProxy(parent.0))
        } else {
            Err("This AVCapturePhoto cannot be downcasted to AVCaptureDeferredPhotoProxy")
        }
    }
}
impl INSObject for AVCaptureDeferredPhotoProxy {}
impl PNSObject for AVCaptureDeferredPhotoProxy {}
impl IAVCaptureDeferredPhotoProxy for AVCaptureDeferredPhotoProxy {}
pub trait IAVCaptureDeferredPhotoProxy: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeferredPhotoProxy").unwrap(), new)
    }
}
pub trait PAVCapturePhotoFileDataRepresentationCustomizer: Sized + std::ops::Deref {
    unsafe fn replacementMetadataForPhoto_(&self, photo: AVCapturePhoto) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementMetadataForPhoto : photo)
    }
    unsafe fn replacementEmbeddedThumbnailPixelBufferWithPhotoFormat_forPhoto_(
        &self,
        replacementEmbeddedThumbnailPhotoFormatOut: *mut NSDictionary,
        photo: AVCapturePhoto,
    ) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementEmbeddedThumbnailPixelBufferWithPhotoFormat : replacementEmbeddedThumbnailPhotoFormatOut, forPhoto : photo)
    }
    unsafe fn replacementDepthDataForPhoto_(&self, photo: AVCapturePhoto) -> AVDepthData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementDepthDataForPhoto : photo)
    }
    unsafe fn replacementPortraitEffectsMatteForPhoto_(
        &self,
        photo: AVCapturePhoto,
    ) -> AVPortraitEffectsMatte
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementPortraitEffectsMatteForPhoto : photo)
    }
    unsafe fn replacementSemanticSegmentationMatteOfType_forPhoto_(
        &self,
        semanticSegmentationMatteType: NSString,
        photo: AVCapturePhoto,
    ) -> AVSemanticSegmentationMatte
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementSemanticSegmentationMatteOfType : semanticSegmentationMatteType, forPhoto : photo)
    }
    unsafe fn replacementAppleProRAWCompressionSettingsForPhoto_defaultSettings_maximumBitDepth_(
        &self,
        photo: AVCapturePhoto,
        defaultSettings: NSDictionary,
        maximumBitDepth: NSInteger,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, replacementAppleProRAWCompressionSettingsForPhoto : photo, defaultSettings : defaultSettings, maximumBitDepth : maximumBitDepth)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureStillImageOutput(pub id);
impl std::ops::Deref for AVCaptureStillImageOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureStillImageOutput {}
impl AVCaptureStillImageOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureStillImageOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureStillImageOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureStillImageOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureStillImageOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureStillImageOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureStillImageOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureStillImageOutput")
        }
    }
}
impl INSObject for AVCaptureStillImageOutput {}
impl PNSObject for AVCaptureStillImageOutput {}
impl IAVCaptureStillImageOutput for AVCaptureStillImageOutput {}
pub trait IAVCaptureStillImageOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn captureStillImageAsynchronouslyFromConnection_completionHandler_(
        &self,
        connection: AVCaptureConnection,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureStillImageAsynchronouslyFromConnection : connection, completionHandler : handler)
    }
    unsafe fn outputSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, outputSettings)
    }
    unsafe fn setOutputSettings_(&self, outputSettings: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOutputSettings : outputSettings)
    }
    unsafe fn availableImageDataCVPixelFormatTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableImageDataCVPixelFormatTypes)
    }
    unsafe fn availableImageDataCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableImageDataCodecTypes)
    }
    unsafe fn isStillImageStabilizationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStillImageStabilizationSupported)
    }
    unsafe fn automaticallyEnablesStillImageStabilizationWhenAvailable(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyEnablesStillImageStabilizationWhenAvailable)
    }
    unsafe fn setAutomaticallyEnablesStillImageStabilizationWhenAvailable_(
        &self,
        automaticallyEnablesStillImageStabilizationWhenAvailable: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyEnablesStillImageStabilizationWhenAvailable : automaticallyEnablesStillImageStabilizationWhenAvailable)
    }
    unsafe fn isStillImageStabilizationActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isStillImageStabilizationActive)
    }
    unsafe fn isHighResolutionStillImageOutputEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isHighResolutionStillImageOutputEnabled)
    }
    unsafe fn setHighResolutionStillImageOutputEnabled_(
        &self,
        highResolutionStillImageOutputEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setHighResolutionStillImageOutputEnabled : highResolutionStillImageOutputEnabled)
    }
    unsafe fn isCameraSensorOrientationCompensationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraSensorOrientationCompensationSupported)
    }
    unsafe fn isCameraSensorOrientationCompensationEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCameraSensorOrientationCompensationEnabled)
    }
    unsafe fn setCameraSensorOrientationCompensationEnabled_(
        &self,
        cameraSensorOrientationCompensationEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCameraSensorOrientationCompensationEnabled : cameraSensorOrientationCompensationEnabled)
    }
    unsafe fn isCapturingStillImage(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCapturingStillImage)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureStillImageOutput").unwrap(), new)
    }
    unsafe fn jpegStillImageNSDataRepresentation_(jpegSampleBuffer: CMSampleBufferRef) -> NSData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureStillImageOutput").unwrap(), jpegStillImageNSDataRepresentation : jpegSampleBuffer)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureBracketedStillImageSettings(pub id);
impl std::ops::Deref for AVCaptureBracketedStillImageSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureBracketedStillImageSettings {}
impl AVCaptureBracketedStillImageSettings {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureBracketedStillImageSettings").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureBracketedStillImageSettings {}
impl PNSObject for AVCaptureBracketedStillImageSettings {}
impl std::convert::TryFrom<NSObject> for AVCaptureBracketedStillImageSettings {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureBracketedStillImageSettings, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureBracketedStillImageSettings").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureBracketedStillImageSettings(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureBracketedStillImageSettings")
        }
    }
}
impl IAVCaptureBracketedStillImageSettings for AVCaptureBracketedStillImageSettings {}
pub trait IAVCaptureBracketedStillImageSettings: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureBracketedStillImageSettings").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureManualExposureBracketedStillImageSettings(pub id);
impl std::ops::Deref for AVCaptureManualExposureBracketedStillImageSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureManualExposureBracketedStillImageSettings {}
impl AVCaptureManualExposureBracketedStillImageSettings {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureManualExposureBracketedStillImageSettings").unwrap(), alloc)
        })
    }
}
impl IAVCaptureBracketedStillImageSettings for AVCaptureManualExposureBracketedStillImageSettings {}
impl From<AVCaptureManualExposureBracketedStillImageSettings>
    for AVCaptureBracketedStillImageSettings
{
    fn from(
        child: AVCaptureManualExposureBracketedStillImageSettings,
    ) -> AVCaptureBracketedStillImageSettings {
        AVCaptureBracketedStillImageSettings(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureBracketedStillImageSettings>
    for AVCaptureManualExposureBracketedStillImageSettings
{
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureBracketedStillImageSettings,
    ) -> Result<AVCaptureManualExposureBracketedStillImageSettings, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureManualExposureBracketedStillImageSettings").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureManualExposureBracketedStillImageSettings(parent.0))
        } else {
            Err ("This AVCaptureBracketedStillImageSettings cannot be downcasted to AVCaptureManualExposureBracketedStillImageSettings" ,)
        }
    }
}
impl INSObject for AVCaptureManualExposureBracketedStillImageSettings {}
impl PNSObject for AVCaptureManualExposureBracketedStillImageSettings {}
impl IAVCaptureManualExposureBracketedStillImageSettings
    for AVCaptureManualExposureBracketedStillImageSettings
{
}
pub trait IAVCaptureManualExposureBracketedStillImageSettings: Sized + std::ops::Deref {
    unsafe fn exposureDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureDuration)
    }
    unsafe fn ISO(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, ISO)
    }
    unsafe fn manualExposureSettingsWithExposureDuration_ISO_(
        duration: CMTime,
        ISO: f32,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureManualExposureBracketedStillImageSettings").unwrap(), manualExposureSettingsWithExposureDuration : duration, ISO : ISO)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureAutoExposureBracketedStillImageSettings(pub id);
impl std::ops::Deref for AVCaptureAutoExposureBracketedStillImageSettings {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureAutoExposureBracketedStillImageSettings {}
impl AVCaptureAutoExposureBracketedStillImageSettings {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAutoExposureBracketedStillImageSettings").unwrap(), alloc)
        })
    }
}
impl IAVCaptureBracketedStillImageSettings for AVCaptureAutoExposureBracketedStillImageSettings {}
impl std::convert::TryFrom<AVCaptureBracketedStillImageSettings>
    for AVCaptureAutoExposureBracketedStillImageSettings
{
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureBracketedStillImageSettings,
    ) -> Result<AVCaptureAutoExposureBracketedStillImageSettings, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureAutoExposureBracketedStillImageSettings").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureAutoExposureBracketedStillImageSettings(parent.0))
        } else {
            Err ("This AVCaptureBracketedStillImageSettings cannot be downcasted to AVCaptureAutoExposureBracketedStillImageSettings" ,)
        }
    }
}
impl INSObject for AVCaptureAutoExposureBracketedStillImageSettings {}
impl PNSObject for AVCaptureAutoExposureBracketedStillImageSettings {}
impl IAVCaptureAutoExposureBracketedStillImageSettings
    for AVCaptureAutoExposureBracketedStillImageSettings
{
}
pub trait IAVCaptureAutoExposureBracketedStillImageSettings: Sized + std::ops::Deref {
    unsafe fn exposureTargetBias(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, exposureTargetBias)
    }
    unsafe fn autoExposureSettingsWithExposureTargetBias_(exposureTargetBias: f32) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureAutoExposureBracketedStillImageSettings").unwrap(), autoExposureSettingsWithExposureTargetBias : exposureTargetBias)
    }
}
impl AVCaptureStillImageOutput_AVCaptureStillImageOutputBracketedCapture
    for AVCaptureStillImageOutput
{
}
pub trait AVCaptureStillImageOutput_AVCaptureStillImageOutputBracketedCapture:
    Sized + std::ops::Deref
{
    unsafe fn prepareToCaptureStillImageBracketFromConnection_withSettingsArray_completionHandler_(
        &self,
        connection: AVCaptureConnection,
        settings: NSArray,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, prepareToCaptureStillImageBracketFromConnection : connection, withSettingsArray : settings, completionHandler : handler)
    }
    unsafe fn captureStillImageBracketAsynchronouslyFromConnection_withSettingsArray_completionHandler_(
        &self,
        connection: AVCaptureConnection,
        settings: NSArray,
        handler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureStillImageBracketAsynchronouslyFromConnection : connection, withSettingsArray : settings, completionHandler : handler)
    }
    unsafe fn maxBracketedCaptureStillImageCount(&self) -> NSUInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, maxBracketedCaptureStillImageCount)
    }
    unsafe fn isLensStabilizationDuringBracketedCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLensStabilizationDuringBracketedCaptureSupported)
    }
    unsafe fn isLensStabilizationDuringBracketedCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLensStabilizationDuringBracketedCaptureEnabled)
    }
    unsafe fn setLensStabilizationDuringBracketedCaptureEnabled_(
        &self,
        lensStabilizationDuringBracketedCaptureEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLensStabilizationDuringBracketedCaptureEnabled : lensStabilizationDuringBracketedCaptureEnabled)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureVideoDataOutput(pub id);
impl std::ops::Deref for AVCaptureVideoDataOutput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureVideoDataOutput {}
impl AVCaptureVideoDataOutput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureVideoDataOutput").unwrap(), alloc) })
    }
}
impl IAVCaptureOutput for AVCaptureVideoDataOutput {}
impl std::convert::TryFrom<AVCaptureOutput> for AVCaptureVideoDataOutput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureOutput) -> Result<AVCaptureVideoDataOutput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureVideoDataOutput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureVideoDataOutput(parent.0))
        } else {
            Err("This AVCaptureOutput cannot be downcasted to AVCaptureVideoDataOutput")
        }
    }
}
impl INSObject for AVCaptureVideoDataOutput {}
impl PNSObject for AVCaptureVideoDataOutput {}
impl IAVCaptureVideoDataOutput for AVCaptureVideoDataOutput {}
pub trait IAVCaptureVideoDataOutput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn setSampleBufferDelegate_queue_(
        &self,
        sampleBufferDelegate: *mut u64,
        sampleBufferCallbackQueue: NSObject,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSampleBufferDelegate : sampleBufferDelegate, queue : sampleBufferCallbackQueue)
    }
    unsafe fn recommendedVideoSettingsForAssetWriterWithOutputFileType_(
        &self,
        outputFileType: NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recommendedVideoSettingsForAssetWriterWithOutputFileType : outputFileType)
    }
    unsafe fn availableVideoCodecTypesForAssetWriterWithOutputFileType_(
        &self,
        outputFileType: NSString,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, availableVideoCodecTypesForAssetWriterWithOutputFileType : outputFileType)
    }
    unsafe fn recommendedVideoSettingsForVideoCodecType_assetWriterOutputFileType_(
        &self,
        videoCodecType: NSString,
        outputFileType: NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recommendedVideoSettingsForVideoCodecType : videoCodecType, assetWriterOutputFileType : outputFileType)
    }
    unsafe fn recommendedVideoSettingsForVideoCodecType_assetWriterOutputFileType_outputFileURL_(
        &self,
        videoCodecType: NSString,
        outputFileType: NSString,
        outputFileURL: NSURL,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recommendedVideoSettingsForVideoCodecType : videoCodecType, assetWriterOutputFileType : outputFileType, outputFileURL : outputFileURL)
    }
    unsafe fn recommendedMovieMetadataForVideoCodecType_assetWriterOutputFileType_(
        &self,
        videoCodecType: NSString,
        outputFileType: NSString,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, recommendedMovieMetadataForVideoCodecType : videoCodecType, assetWriterOutputFileType : outputFileType)
    }
    unsafe fn sampleBufferDelegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferDelegate)
    }
    unsafe fn sampleBufferCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferCallbackQueue)
    }
    unsafe fn videoSettings(&self) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoSettings)
    }
    unsafe fn setVideoSettings_(&self, videoSettings: NSDictionary)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoSettings : videoSettings)
    }
    unsafe fn recommendedMediaTimeScaleForAssetWriter(&self) -> CMTimeScale
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, recommendedMediaTimeScaleForAssetWriter)
    }
    unsafe fn availableVideoCVPixelFormatTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableVideoCVPixelFormatTypes)
    }
    unsafe fn availableVideoCodecTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableVideoCodecTypes)
    }
    unsafe fn minFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFrameDuration)
    }
    unsafe fn setMinFrameDuration_(&self, minFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMinFrameDuration : minFrameDuration)
    }
    unsafe fn alwaysDiscardsLateVideoFrames(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, alwaysDiscardsLateVideoFrames)
    }
    unsafe fn setAlwaysDiscardsLateVideoFrames_(&self, alwaysDiscardsLateVideoFrames: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAlwaysDiscardsLateVideoFrames : alwaysDiscardsLateVideoFrames)
    }
    unsafe fn automaticallyConfiguresOutputBufferDimensions(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyConfiguresOutputBufferDimensions)
    }
    unsafe fn setAutomaticallyConfiguresOutputBufferDimensions_(
        &self,
        automaticallyConfiguresOutputBufferDimensions: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyConfiguresOutputBufferDimensions : automaticallyConfiguresOutputBufferDimensions)
    }
    unsafe fn deliversPreviewSizedOutputBuffers(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, deliversPreviewSizedOutputBuffers)
    }
    unsafe fn setDeliversPreviewSizedOutputBuffers_(&self, deliversPreviewSizedOutputBuffers: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDeliversPreviewSizedOutputBuffers : deliversPreviewSizedOutputBuffers)
    }
    unsafe fn preparesCellularRadioForNetworkConnection(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preparesCellularRadioForNetworkConnection)
    }
    unsafe fn setPreparesCellularRadioForNetworkConnection_(
        &self,
        preparesCellularRadioForNetworkConnection: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreparesCellularRadioForNetworkConnection : preparesCellularRadioForNetworkConnection)
    }
    unsafe fn preservesDynamicHDRMetadata(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preservesDynamicHDRMetadata)
    }
    unsafe fn setPreservesDynamicHDRMetadata_(&self, preservesDynamicHDRMetadata: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreservesDynamicHDRMetadata : preservesDynamicHDRMetadata)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureVideoDataOutput").unwrap(), new)
    }
}
pub trait PAVCaptureVideoDataOutputSampleBufferDelegate: Sized + std::ops::Deref {
    unsafe fn captureOutput_didOutputSampleBuffer_fromConnection_(
        &self,
        output: AVCaptureOutput,
        sampleBuffer: CMSampleBufferRef,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didOutputSampleBuffer : sampleBuffer, fromConnection : connection)
    }
    unsafe fn captureOutput_didDropSampleBuffer_fromConnection_(
        &self,
        output: AVCaptureOutput,
        sampleBuffer: CMSampleBufferRef,
        connection: AVCaptureConnection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureOutput : output, didDropSampleBuffer : sampleBuffer, fromConnection : connection)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDataOutputSynchronizer(pub id);
impl std::ops::Deref for AVCaptureDataOutputSynchronizer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDataOutputSynchronizer {}
impl AVCaptureDataOutputSynchronizer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDataOutputSynchronizer").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDataOutputSynchronizer {}
impl PNSObject for AVCaptureDataOutputSynchronizer {}
impl std::convert::TryFrom<NSObject> for AVCaptureDataOutputSynchronizer {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDataOutputSynchronizer, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDataOutputSynchronizer").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureDataOutputSynchronizer(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDataOutputSynchronizer")
        }
    }
}
impl IAVCaptureDataOutputSynchronizer for AVCaptureDataOutputSynchronizer {}
pub trait IAVCaptureDataOutputSynchronizer: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithDataOutputs_(&self, dataOutputs: NSArray) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDataOutputs : dataOutputs)
    }
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, delegateCallbackQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : delegateCallbackQueue)
    }
    unsafe fn dataOutputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, dataOutputs)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateCallbackQueue)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDataOutputSynchronizer").unwrap(), new)
    }
}
pub trait PAVCaptureDataOutputSynchronizerDelegate: Sized + std::ops::Deref {
    unsafe fn dataOutputSynchronizer_didOutputSynchronizedDataCollection_(
        &self,
        synchronizer: AVCaptureDataOutputSynchronizer,
        synchronizedDataCollection: AVCaptureSynchronizedDataCollection,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dataOutputSynchronizer : synchronizer, didOutputSynchronizedDataCollection : synchronizedDataCollection)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSynchronizedDataCollection(pub id);
impl std::ops::Deref for AVCaptureSynchronizedDataCollection {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSynchronizedDataCollection {}
impl AVCaptureSynchronizedDataCollection {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedDataCollection").unwrap(), alloc) })
    }
}
impl PNSFastEnumeration for AVCaptureSynchronizedDataCollection {}
impl INSObject for AVCaptureSynchronizedDataCollection {}
impl PNSObject for AVCaptureSynchronizedDataCollection {}
impl std::convert::TryFrom<NSObject> for AVCaptureSynchronizedDataCollection {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureSynchronizedDataCollection, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedDataCollection").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSynchronizedDataCollection(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureSynchronizedDataCollection")
        }
    }
}
impl IAVCaptureSynchronizedDataCollection for AVCaptureSynchronizedDataCollection {}
pub trait IAVCaptureSynchronizedDataCollection: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn synchronizedDataForCaptureOutput_(
        &self,
        captureOutput: AVCaptureOutput,
    ) -> AVCaptureSynchronizedData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, synchronizedDataForCaptureOutput : captureOutput)
    }
    unsafe fn objectForKeyedSubscript_(&self, key: AVCaptureOutput) -> AVCaptureSynchronizedData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, objectForKeyedSubscript : key)
    }
    unsafe fn count(&self) -> NSUInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, count)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedDataCollection").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSynchronizedData(pub id);
impl std::ops::Deref for AVCaptureSynchronizedData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSynchronizedData {}
impl AVCaptureSynchronizedData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedData").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureSynchronizedData {}
impl PNSObject for AVCaptureSynchronizedData {}
impl std::convert::TryFrom<NSObject> for AVCaptureSynchronizedData {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureSynchronizedData, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedData").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSynchronizedData(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureSynchronizedData")
        }
    }
}
impl IAVCaptureSynchronizedData for AVCaptureSynchronizedData {}
pub trait IAVCaptureSynchronizedData: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn timestamp(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timestamp)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedData").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSynchronizedSampleBufferData(pub id);
impl std::ops::Deref for AVCaptureSynchronizedSampleBufferData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSynchronizedSampleBufferData {}
impl AVCaptureSynchronizedSampleBufferData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedSampleBufferData").unwrap(), alloc) })
    }
}
impl IAVCaptureSynchronizedData for AVCaptureSynchronizedSampleBufferData {}
impl From<AVCaptureSynchronizedSampleBufferData> for AVCaptureSynchronizedData {
    fn from(child: AVCaptureSynchronizedSampleBufferData) -> AVCaptureSynchronizedData {
        AVCaptureSynchronizedData(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureSynchronizedData> for AVCaptureSynchronizedSampleBufferData {
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureSynchronizedData,
    ) -> Result<AVCaptureSynchronizedSampleBufferData, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedSampleBufferData").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSynchronizedSampleBufferData(parent.0))
        } else {
            Err ("This AVCaptureSynchronizedData cannot be downcasted to AVCaptureSynchronizedSampleBufferData" ,)
        }
    }
}
impl INSObject for AVCaptureSynchronizedSampleBufferData {}
impl PNSObject for AVCaptureSynchronizedSampleBufferData {}
impl IAVCaptureSynchronizedSampleBufferData for AVCaptureSynchronizedSampleBufferData {}
pub trait IAVCaptureSynchronizedSampleBufferData: Sized + std::ops::Deref {
    unsafe fn sampleBuffer(&self) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBuffer)
    }
    unsafe fn sampleBufferWasDropped(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sampleBufferWasDropped)
    }
    unsafe fn droppedReason(&self) -> AVCaptureOutputDataDroppedReason
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, droppedReason)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSynchronizedMetadataObjectData(pub id);
impl std::ops::Deref for AVCaptureSynchronizedMetadataObjectData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSynchronizedMetadataObjectData {}
impl AVCaptureSynchronizedMetadataObjectData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedMetadataObjectData").unwrap(), alloc) })
    }
}
impl IAVCaptureSynchronizedData for AVCaptureSynchronizedMetadataObjectData {}
impl std::convert::TryFrom<AVCaptureSynchronizedData> for AVCaptureSynchronizedMetadataObjectData {
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureSynchronizedData,
    ) -> Result<AVCaptureSynchronizedMetadataObjectData, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedMetadataObjectData").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSynchronizedMetadataObjectData(parent.0))
        } else {
            Err ("This AVCaptureSynchronizedData cannot be downcasted to AVCaptureSynchronizedMetadataObjectData" ,)
        }
    }
}
impl INSObject for AVCaptureSynchronizedMetadataObjectData {}
impl PNSObject for AVCaptureSynchronizedMetadataObjectData {}
impl IAVCaptureSynchronizedMetadataObjectData for AVCaptureSynchronizedMetadataObjectData {}
pub trait IAVCaptureSynchronizedMetadataObjectData: Sized + std::ops::Deref {
    unsafe fn metadataObjects(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, metadataObjects)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSynchronizedDepthData(pub id);
impl std::ops::Deref for AVCaptureSynchronizedDepthData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSynchronizedDepthData {}
impl AVCaptureSynchronizedDepthData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedDepthData").unwrap(), alloc) })
    }
}
impl IAVCaptureSynchronizedData for AVCaptureSynchronizedDepthData {}
impl std::convert::TryFrom<AVCaptureSynchronizedData> for AVCaptureSynchronizedDepthData {
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureSynchronizedData,
    ) -> Result<AVCaptureSynchronizedDepthData, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSynchronizedDepthData").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSynchronizedDepthData(parent.0))
        } else {
            Err ("This AVCaptureSynchronizedData cannot be downcasted to AVCaptureSynchronizedDepthData" ,)
        }
    }
}
impl INSObject for AVCaptureSynchronizedDepthData {}
impl PNSObject for AVCaptureSynchronizedDepthData {}
impl IAVCaptureSynchronizedDepthData for AVCaptureSynchronizedDepthData {}
pub trait IAVCaptureSynchronizedDepthData: Sized + std::ops::Deref {
    unsafe fn depthData(&self) -> AVDepthData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthData)
    }
    unsafe fn depthDataWasDropped(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthDataWasDropped)
    }
    unsafe fn droppedReason(&self) -> AVCaptureOutputDataDroppedReason
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, droppedReason)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeskViewApplication(pub id);
impl std::ops::Deref for AVCaptureDeskViewApplication {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeskViewApplication {}
impl AVCaptureDeskViewApplication {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeskViewApplication").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureDeskViewApplication {}
impl PNSObject for AVCaptureDeskViewApplication {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeskViewApplication {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureDeskViewApplication, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeskViewApplication").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDeskViewApplication(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureDeskViewApplication")
        }
    }
}
impl IAVCaptureDeskViewApplication for AVCaptureDeskViewApplication {}
pub trait IAVCaptureDeskViewApplication: Sized + std::ops::Deref {
    unsafe fn presentWithCompletionHandler_(&self, completionHandler: *mut ::std::os::raw::c_void)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, presentWithCompletionHandler : completionHandler)
    }
    unsafe fn presentWithLaunchConfiguration_completionHandler_(
        &self,
        launchConfiguration: AVCaptureDeskViewApplicationLaunchConfiguration,
        completionHandler: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, presentWithLaunchConfiguration : launchConfiguration, completionHandler : completionHandler)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeskViewApplicationLaunchConfiguration(pub id);
impl std::ops::Deref for AVCaptureDeskViewApplicationLaunchConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeskViewApplicationLaunchConfiguration {}
impl AVCaptureDeskViewApplicationLaunchConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe {
            msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeskViewApplicationLaunchConfiguration").unwrap(), alloc)
        })
    }
}
impl INSObject for AVCaptureDeskViewApplicationLaunchConfiguration {}
impl PNSObject for AVCaptureDeskViewApplicationLaunchConfiguration {}
impl std::convert::TryFrom<NSObject> for AVCaptureDeskViewApplicationLaunchConfiguration {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVCaptureDeskViewApplicationLaunchConfiguration, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeskViewApplicationLaunchConfiguration").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureDeskViewApplicationLaunchConfiguration(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVCaptureDeskViewApplicationLaunchConfiguration" ,)
        }
    }
}
impl IAVCaptureDeskViewApplicationLaunchConfiguration
    for AVCaptureDeskViewApplicationLaunchConfiguration
{
}
pub trait IAVCaptureDeskViewApplicationLaunchConfiguration: Sized + std::ops::Deref {
    unsafe fn mainWindowFrame(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mainWindowFrame)
    }
    unsafe fn setMainWindowFrame_(&self, mainWindowFrame: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMainWindowFrame : mainWindowFrame)
    }
    unsafe fn requiresSetUpModeCompletion(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, requiresSetUpModeCompletion)
    }
    unsafe fn setRequiresSetUpModeCompletion_(&self, requiresSetUpModeCompletion: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRequiresSetUpModeCompletion : requiresSetUpModeCompletion)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureExternalDisplayConfiguration(pub id);
impl std::ops::Deref for AVCaptureExternalDisplayConfiguration {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureExternalDisplayConfiguration {}
impl AVCaptureExternalDisplayConfiguration {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfiguration").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureExternalDisplayConfiguration {}
impl PNSObject for AVCaptureExternalDisplayConfiguration {}
impl std::convert::TryFrom<NSObject> for AVCaptureExternalDisplayConfiguration {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureExternalDisplayConfiguration, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfiguration").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureExternalDisplayConfiguration(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureExternalDisplayConfiguration")
        }
    }
}
impl IAVCaptureExternalDisplayConfiguration for AVCaptureExternalDisplayConfiguration {}
pub trait IAVCaptureExternalDisplayConfiguration: Sized + std::ops::Deref {
    unsafe fn shouldMatchFrameRate(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, shouldMatchFrameRate)
    }
    unsafe fn setShouldMatchFrameRate_(&self, shouldMatchFrameRate: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setShouldMatchFrameRate : shouldMatchFrameRate)
    }
    unsafe fn bypassColorSpaceConversion(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, bypassColorSpaceConversion)
    }
    unsafe fn setBypassColorSpaceConversion_(&self, bypassColorSpaceConversion: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setBypassColorSpaceConversion : bypassColorSpaceConversion)
    }
    unsafe fn preferredResolution(&self) -> CMVideoDimensions
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, preferredResolution)
    }
    unsafe fn setPreferredResolution_(&self, preferredResolution: CMVideoDimensions)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setPreferredResolution : preferredResolution)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureExternalDisplayConfigurator(pub id);
impl std::ops::Deref for AVCaptureExternalDisplayConfigurator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureExternalDisplayConfigurator {}
impl AVCaptureExternalDisplayConfigurator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureExternalDisplayConfigurator {}
impl PNSObject for AVCaptureExternalDisplayConfigurator {}
impl std::convert::TryFrom<NSObject> for AVCaptureExternalDisplayConfigurator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureExternalDisplayConfigurator, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureExternalDisplayConfigurator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureExternalDisplayConfigurator")
        }
    }
}
impl IAVCaptureExternalDisplayConfigurator for AVCaptureExternalDisplayConfigurator {}
pub trait IAVCaptureExternalDisplayConfigurator: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithDevice_previewLayer_configuration_(
        &self,
        device: AVCaptureDevice,
        previewLayer: CALayer,
        configuration: AVCaptureExternalDisplayConfiguration,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device, previewLayer : previewLayer, configuration : configuration)
    }
    unsafe fn stop(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, stop)
    }
    unsafe fn device(&self) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, device)
    }
    unsafe fn previewLayer(&self) -> CALayer
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, previewLayer)
    }
    unsafe fn isActive(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isActive)
    }
    unsafe fn activeExternalDisplayFrameRate(&self) -> f64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeExternalDisplayFrameRate)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap(), new)
    }
    unsafe fn isMatchingFrameRateSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap(), isMatchingFrameRateSupported)
    }
    unsafe fn isBypassingColorSpaceConversionSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap(), isBypassingColorSpaceConversionSupported)
    }
    unsafe fn isPreferredResolutionSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureExternalDisplayConfigurator").unwrap(), isPreferredResolutionSupported)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureIndexPicker(pub id);
impl std::ops::Deref for AVCaptureIndexPicker {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureIndexPicker {}
impl AVCaptureIndexPicker {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureIndexPicker").unwrap(), alloc) })
    }
}
impl IAVCaptureControl for AVCaptureIndexPicker {}
impl From<AVCaptureIndexPicker> for AVCaptureControl {
    fn from(child: AVCaptureIndexPicker) -> AVCaptureControl {
        AVCaptureControl(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureControl> for AVCaptureIndexPicker {
    type Error = &'static str;
    fn try_from(parent: AVCaptureControl) -> Result<AVCaptureIndexPicker, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureIndexPicker").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureIndexPicker(parent.0))
        } else {
            Err("This AVCaptureControl cannot be downcasted to AVCaptureIndexPicker")
        }
    }
}
impl INSObject for AVCaptureIndexPicker {}
impl PNSObject for AVCaptureIndexPicker {}
impl IAVCaptureIndexPicker for AVCaptureIndexPicker {}
pub trait IAVCaptureIndexPicker: Sized + std::ops::Deref {
    unsafe fn initWithLocalizedTitle_symbolName_numberOfIndexes_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        numberOfIndexes: NSInteger,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, numberOfIndexes : numberOfIndexes)
    }
    unsafe fn initWithLocalizedTitle_symbolName_numberOfIndexes_localizedTitleTransform_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        numberOfIndexes: NSInteger,
        localizedTitleTransform: *mut ::std::os::raw::c_void,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, numberOfIndexes : numberOfIndexes, localizedTitleTransform : localizedTitleTransform)
    }
    unsafe fn initWithLocalizedTitle_symbolName_localizedIndexTitles_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        localizedIndexTitles: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, localizedIndexTitles : localizedIndexTitles)
    }
    unsafe fn setActionQueue_action_(
        &self,
        actionQueue: NSObject,
        action: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActionQueue : actionQueue, action : action)
    }
    unsafe fn selectedIndex(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, selectedIndex)
    }
    unsafe fn setSelectedIndex_(&self, selectedIndex: NSInteger)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSelectedIndex : selectedIndex)
    }
    unsafe fn localizedTitle(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedTitle)
    }
    unsafe fn symbolName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, symbolName)
    }
    unsafe fn numberOfIndexes(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, numberOfIndexes)
    }
    unsafe fn localizedIndexTitles(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedIndexTitles)
    }
    unsafe fn accessibilityIdentifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, accessibilityIdentifier)
    }
    unsafe fn setAccessibilityIdentifier_(&self, accessibilityIdentifier: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAccessibilityIdentifier : accessibilityIdentifier)
    }
}
pub type AVExternalSyncDeviceStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVExternalSyncDevice(pub id);
impl std::ops::Deref for AVExternalSyncDevice {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVExternalSyncDevice {}
impl AVExternalSyncDevice {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDevice").unwrap(), alloc) })
    }
}
impl INSObject for AVExternalSyncDevice {}
impl PNSObject for AVExternalSyncDevice {}
impl std::convert::TryFrom<NSObject> for AVExternalSyncDevice {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVExternalSyncDevice, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVExternalSyncDevice").unwrap()) };
        if is_kind_of {
            Ok(AVExternalSyncDevice(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVExternalSyncDevice")
        }
    }
}
impl IAVExternalSyncDevice for AVExternalSyncDevice {}
pub trait IAVExternalSyncDevice: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn status(&self) -> AVExternalSyncDeviceStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, status)
    }
    unsafe fn clock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, clock)
    }
    unsafe fn signalCompensationDelay(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, signalCompensationDelay)
    }
    unsafe fn setSignalCompensationDelay_(&self, signalCompensationDelay: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSignalCompensationDelay : signalCompensationDelay)
    }
    unsafe fn uuid(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uuid)
    }
    unsafe fn vendorID(&self) -> UInt32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, vendorID)
    }
    unsafe fn productID(&self) -> UInt32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, productID)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDevice").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVExternalSyncDeviceDiscoverySession(pub id);
impl std::ops::Deref for AVExternalSyncDeviceDiscoverySession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVExternalSyncDeviceDiscoverySession {}
impl AVExternalSyncDeviceDiscoverySession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDeviceDiscoverySession").unwrap(), alloc) })
    }
}
impl INSObject for AVExternalSyncDeviceDiscoverySession {}
impl PNSObject for AVExternalSyncDeviceDiscoverySession {}
impl std::convert::TryFrom<NSObject> for AVExternalSyncDeviceDiscoverySession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVExternalSyncDeviceDiscoverySession, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVExternalSyncDeviceDiscoverySession").unwrap())
        };
        if is_kind_of {
            Ok(AVExternalSyncDeviceDiscoverySession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVExternalSyncDeviceDiscoverySession")
        }
    }
}
impl IAVExternalSyncDeviceDiscoverySession for AVExternalSyncDeviceDiscoverySession {}
pub trait IAVExternalSyncDeviceDiscoverySession: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn devices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, devices)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDeviceDiscoverySession").unwrap(), new)
    }
    unsafe fn sharedSession() -> AVExternalSyncDeviceDiscoverySession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDeviceDiscoverySession").unwrap(), sharedSession)
    }
    unsafe fn isSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalSyncDeviceDiscoverySession").unwrap(), isSupported)
    }
}
pub trait PAVExternalSyncDeviceDelegate: Sized + std::ops::Deref {
    unsafe fn externalSyncDeviceStatusDidChange_(&self, device: AVExternalSyncDevice)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, externalSyncDeviceStatusDidChange : device)
    }
    unsafe fn externalSyncDevice_failedWithError_(
        &self,
        device: AVExternalSyncDevice,
        error: NSError,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, externalSyncDevice : device, failedWithError : error)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureInput(pub id);
impl std::ops::Deref for AVCaptureInput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureInput {}
impl AVCaptureInput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureInput").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureInput {}
impl PNSObject for AVCaptureInput {}
impl std::convert::TryFrom<NSObject> for AVCaptureInput {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureInput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureInput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureInput(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureInput")
        }
    }
}
impl IAVCaptureInput for AVCaptureInput {}
pub trait IAVCaptureInput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn ports(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, ports)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureInput").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureInputPort(pub id);
impl std::ops::Deref for AVCaptureInputPort {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureInputPort {}
impl AVCaptureInputPort {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureInputPort").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureInputPort {}
impl PNSObject for AVCaptureInputPort {}
impl std::convert::TryFrom<NSObject> for AVCaptureInputPort {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureInputPort, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureInputPort").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureInputPort(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureInputPort")
        }
    }
}
impl IAVCaptureInputPort for AVCaptureInputPort {}
pub trait IAVCaptureInputPort: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn input(&self) -> AVCaptureInput
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, input)
    }
    unsafe fn mediaType(&self) -> AVMediaType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mediaType)
    }
    unsafe fn formatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, formatDescription)
    }
    unsafe fn isEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isEnabled)
    }
    unsafe fn setEnabled_(&self, enabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setEnabled : enabled)
    }
    unsafe fn clock(&self) -> CMClockRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, clock)
    }
    unsafe fn sourceDeviceType(&self) -> AVCaptureDeviceType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceDeviceType)
    }
    unsafe fn sourceDevicePosition(&self) -> AVCaptureDevicePosition
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, sourceDevicePosition)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureInputPort").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureDeviceInput(pub id);
impl std::ops::Deref for AVCaptureDeviceInput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureDeviceInput {}
impl AVCaptureDeviceInput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceInput").unwrap(), alloc) })
    }
}
impl IAVCaptureInput for AVCaptureDeviceInput {}
impl From<AVCaptureDeviceInput> for AVCaptureInput {
    fn from(child: AVCaptureDeviceInput) -> AVCaptureInput {
        AVCaptureInput(child.0)
    }
}
impl std::convert::TryFrom<AVCaptureInput> for AVCaptureDeviceInput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureInput) -> Result<AVCaptureDeviceInput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureDeviceInput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureDeviceInput(parent.0))
        } else {
            Err("This AVCaptureInput cannot be downcasted to AVCaptureDeviceInput")
        }
    }
}
impl INSObject for AVCaptureDeviceInput {}
impl PNSObject for AVCaptureDeviceInput {}
impl IAVCaptureDeviceInput for AVCaptureDeviceInput {}
pub trait IAVCaptureDeviceInput: Sized + std::ops::Deref {
    unsafe fn initWithDevice_error_(
        &self,
        device: AVCaptureDevice,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device, error : outError)
    }
    unsafe fn portsWithMediaType_sourceDeviceType_sourceDevicePosition_(
        &self,
        mediaType: NSString,
        sourceDeviceType: NSString,
        sourceDevicePosition: AVCaptureDevicePosition,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, portsWithMediaType : mediaType, sourceDeviceType : sourceDeviceType, sourceDevicePosition : sourceDevicePosition)
    }
    unsafe fn followExternalSyncDevice_videoFrameDuration_delegate_(
        &self,
        externalSyncDevice: AVExternalSyncDevice,
        frameDuration: CMTime,
        delegate: *mut u64,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, followExternalSyncDevice : externalSyncDevice, videoFrameDuration : frameDuration, delegate : delegate)
    }
    unsafe fn unfollowExternalSyncDevice(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unfollowExternalSyncDevice)
    }
    unsafe fn isMultichannelAudioModeSupported_(
        &self,
        multichannelAudioMode: AVCaptureMultichannelAudioMode,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, isMultichannelAudioModeSupported : multichannelAudioMode)
    }
    unsafe fn device(&self) -> AVCaptureDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, device)
    }
    unsafe fn unifiedAutoExposureDefaultsEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, unifiedAutoExposureDefaultsEnabled)
    }
    unsafe fn setUnifiedAutoExposureDefaultsEnabled_(
        &self,
        unifiedAutoExposureDefaultsEnabled: BOOL,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setUnifiedAutoExposureDefaultsEnabled : unifiedAutoExposureDefaultsEnabled)
    }
    unsafe fn videoMinFrameDurationOverride(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoMinFrameDurationOverride)
    }
    unsafe fn setVideoMinFrameDurationOverride_(&self, videoMinFrameDurationOverride: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoMinFrameDurationOverride : videoMinFrameDurationOverride)
    }
    unsafe fn isLockedVideoFrameDurationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isLockedVideoFrameDurationSupported)
    }
    unsafe fn activeLockedVideoFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeLockedVideoFrameDuration)
    }
    unsafe fn setActiveLockedVideoFrameDuration_(&self, activeLockedVideoFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActiveLockedVideoFrameDuration : activeLockedVideoFrameDuration)
    }
    unsafe fn isExternalSyncSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isExternalSyncSupported)
    }
    unsafe fn activeExternalSyncVideoFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, activeExternalSyncVideoFrameDuration)
    }
    unsafe fn externalSyncDevice(&self) -> AVExternalSyncDevice
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, externalSyncDevice)
    }
    unsafe fn multichannelAudioMode(&self) -> AVCaptureMultichannelAudioMode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, multichannelAudioMode)
    }
    unsafe fn setMultichannelAudioMode_(
        &self,
        multichannelAudioMode: AVCaptureMultichannelAudioMode,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMultichannelAudioMode : multichannelAudioMode)
    }
    unsafe fn isWindNoiseRemovalSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isWindNoiseRemovalSupported)
    }
    unsafe fn isWindNoiseRemovalEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isWindNoiseRemovalEnabled)
    }
    unsafe fn setWindNoiseRemovalEnabled_(&self, windNoiseRemovalEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setWindNoiseRemovalEnabled : windNoiseRemovalEnabled)
    }
    unsafe fn isCinematicVideoCaptureSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCinematicVideoCaptureSupported)
    }
    unsafe fn isCinematicVideoCaptureEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isCinematicVideoCaptureEnabled)
    }
    unsafe fn setCinematicVideoCaptureEnabled_(&self, cinematicVideoCaptureEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCinematicVideoCaptureEnabled : cinematicVideoCaptureEnabled)
    }
    unsafe fn simulatedAperture(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, simulatedAperture)
    }
    unsafe fn setSimulatedAperture_(&self, simulatedAperture: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSimulatedAperture : simulatedAperture)
    }
    unsafe fn deviceInputWithDevice_error_(
        device: AVCaptureDevice,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureDeviceInput").unwrap(), deviceInputWithDevice : device, error : outError)
    }
}
pub type AVCaptureMultichannelAudioMode = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureScreenInput(pub id);
impl std::ops::Deref for AVCaptureScreenInput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureScreenInput {}
impl AVCaptureScreenInput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureScreenInput").unwrap(), alloc) })
    }
}
impl IAVCaptureInput for AVCaptureScreenInput {}
impl std::convert::TryFrom<AVCaptureInput> for AVCaptureScreenInput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureInput) -> Result<AVCaptureScreenInput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureScreenInput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureScreenInput(parent.0))
        } else {
            Err("This AVCaptureInput cannot be downcasted to AVCaptureScreenInput")
        }
    }
}
impl INSObject for AVCaptureScreenInput {}
impl PNSObject for AVCaptureScreenInput {}
impl IAVCaptureScreenInput for AVCaptureScreenInput {}
pub trait IAVCaptureScreenInput: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn initWithDisplayID_(&self, displayID: CGDirectDisplayID) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDisplayID : displayID)
    }
    unsafe fn minFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, minFrameDuration)
    }
    unsafe fn setMinFrameDuration_(&self, minFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMinFrameDuration : minFrameDuration)
    }
    unsafe fn cropRect(&self) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cropRect)
    }
    unsafe fn setCropRect_(&self, cropRect: CGRect)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCropRect : cropRect)
    }
    unsafe fn scaleFactor(&self) -> CGFloat
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, scaleFactor)
    }
    unsafe fn setScaleFactor_(&self, scaleFactor: CGFloat)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setScaleFactor : scaleFactor)
    }
    unsafe fn capturesMouseClicks(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, capturesMouseClicks)
    }
    unsafe fn setCapturesMouseClicks_(&self, capturesMouseClicks: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCapturesMouseClicks : capturesMouseClicks)
    }
    unsafe fn capturesCursor(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, capturesCursor)
    }
    unsafe fn setCapturesCursor_(&self, capturesCursor: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setCapturesCursor : capturesCursor)
    }
    unsafe fn removesDuplicateFrames(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, removesDuplicateFrames)
    }
    unsafe fn setRemovesDuplicateFrames_(&self, removesDuplicateFrames: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setRemovesDuplicateFrames : removesDuplicateFrames)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureScreenInput").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureMetadataInput(pub id);
impl std::ops::Deref for AVCaptureMetadataInput {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureMetadataInput {}
impl AVCaptureMetadataInput {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMetadataInput").unwrap(), alloc) })
    }
}
impl IAVCaptureInput for AVCaptureMetadataInput {}
impl std::convert::TryFrom<AVCaptureInput> for AVCaptureMetadataInput {
    type Error = &'static str;
    fn try_from(parent: AVCaptureInput) -> Result<AVCaptureMetadataInput, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureMetadataInput").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureMetadataInput(parent.0))
        } else {
            Err("This AVCaptureInput cannot be downcasted to AVCaptureMetadataInput")
        }
    }
}
impl INSObject for AVCaptureMetadataInput {}
impl PNSObject for AVCaptureMetadataInput {}
impl IAVCaptureMetadataInput for AVCaptureMetadataInput {}
pub trait IAVCaptureMetadataInput: Sized + std::ops::Deref {
    unsafe fn initWithFormatDescription_clock_(
        &self,
        desc: CMMetadataFormatDescriptionRef,
        clock: CMClockRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithFormatDescription : desc, clock : clock)
    }
    unsafe fn appendTimedMetadataGroup_error_(
        &self,
        metadata: AVTimedMetadataGroup,
        outError: *mut NSError,
    ) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, appendTimedMetadataGroup : metadata, error : outError)
    }
    unsafe fn metadataInputWithFormatDescription_clock_(
        desc: CMMetadataFormatDescriptionRef,
        clock: CMClockRef,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureMetadataInput").unwrap(), metadataInputWithFormatDescription : desc, clock : clock)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSlider(pub id);
impl std::ops::Deref for AVCaptureSlider {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSlider {}
impl AVCaptureSlider {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSlider").unwrap(), alloc) })
    }
}
impl IAVCaptureControl for AVCaptureSlider {}
impl std::convert::TryFrom<AVCaptureControl> for AVCaptureSlider {
    type Error = &'static str;
    fn try_from(parent: AVCaptureControl) -> Result<AVCaptureSlider, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSlider").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSlider(parent.0))
        } else {
            Err("This AVCaptureControl cannot be downcasted to AVCaptureSlider")
        }
    }
}
impl INSObject for AVCaptureSlider {}
impl PNSObject for AVCaptureSlider {}
impl IAVCaptureSlider for AVCaptureSlider {}
pub trait IAVCaptureSlider: Sized + std::ops::Deref {
    unsafe fn initWithLocalizedTitle_symbolName_minValue_maxValue_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        minValue: f32,
        maxValue: f32,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, minValue : minValue, maxValue : maxValue)
    }
    unsafe fn initWithLocalizedTitle_symbolName_minValue_maxValue_step_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        minValue: f32,
        maxValue: f32,
        step: f32,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, minValue : minValue, maxValue : maxValue, step : step)
    }
    unsafe fn initWithLocalizedTitle_symbolName_values_(
        &self,
        localizedTitle: NSString,
        symbolName: NSString,
        values: NSArray,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithLocalizedTitle : localizedTitle, symbolName : symbolName, values : values)
    }
    unsafe fn setActionQueue_action_(
        &self,
        actionQueue: NSObject,
        action: *mut ::std::os::raw::c_void,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setActionQueue : actionQueue, action : action)
    }
    unsafe fn value(&self) -> f32
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, value)
    }
    unsafe fn setValue_(&self, value: f32)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setValue : value)
    }
    unsafe fn localizedValueFormat(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedValueFormat)
    }
    unsafe fn setLocalizedValueFormat_(&self, localizedValueFormat: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setLocalizedValueFormat : localizedValueFormat)
    }
    unsafe fn prominentValues(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, prominentValues)
    }
    unsafe fn setProminentValues_(&self, prominentValues: NSArray)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setProminentValues : prominentValues)
    }
    unsafe fn localizedTitle(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, localizedTitle)
    }
    unsafe fn symbolName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, symbolName)
    }
    unsafe fn accessibilityIdentifier(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, accessibilityIdentifier)
    }
    unsafe fn setAccessibilityIdentifier_(&self, accessibilityIdentifier: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAccessibilityIdentifier : accessibilityIdentifier)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSystemExposureBiasSlider(pub id);
impl std::ops::Deref for AVCaptureSystemExposureBiasSlider {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSystemExposureBiasSlider {}
impl AVCaptureSystemExposureBiasSlider {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSystemExposureBiasSlider").unwrap(), alloc) })
    }
}
impl IAVCaptureControl for AVCaptureSystemExposureBiasSlider {}
impl std::convert::TryFrom<AVCaptureControl> for AVCaptureSystemExposureBiasSlider {
    type Error = &'static str;
    fn try_from(
        parent: AVCaptureControl,
    ) -> Result<AVCaptureSystemExposureBiasSlider, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSystemExposureBiasSlider").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSystemExposureBiasSlider(parent.0))
        } else {
            Err("This AVCaptureControl cannot be downcasted to AVCaptureSystemExposureBiasSlider")
        }
    }
}
impl INSObject for AVCaptureSystemExposureBiasSlider {}
impl PNSObject for AVCaptureSystemExposureBiasSlider {}
impl IAVCaptureSystemExposureBiasSlider for AVCaptureSystemExposureBiasSlider {}
pub trait IAVCaptureSystemExposureBiasSlider: Sized + std::ops::Deref {
    unsafe fn initWithDevice_(&self, device: AVCaptureDevice) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device)
    }
    unsafe fn initWithDevice_action_(
        &self,
        device: AVCaptureDevice,
        action: *mut ::std::os::raw::c_void,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device, action : action)
    }
}
pub type AVCaptureSystemPressureLevel = NSString;
pub type AVCaptureSystemPressureFactors = NSUInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSystemPressureState(pub id);
impl std::ops::Deref for AVCaptureSystemPressureState {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSystemPressureState {}
impl AVCaptureSystemPressureState {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSystemPressureState").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureSystemPressureState {}
impl PNSObject for AVCaptureSystemPressureState {}
impl std::convert::TryFrom<NSObject> for AVCaptureSystemPressureState {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureSystemPressureState, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSystemPressureState").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSystemPressureState(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureSystemPressureState")
        }
    }
}
impl IAVCaptureSystemPressureState for AVCaptureSystemPressureState {}
pub trait IAVCaptureSystemPressureState: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn level(&self) -> AVCaptureSystemPressureLevel
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, level)
    }
    unsafe fn factors(&self) -> AVCaptureSystemPressureFactors
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, factors)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSystemPressureState").unwrap(), new)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSystemZoomSlider(pub id);
impl std::ops::Deref for AVCaptureSystemZoomSlider {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSystemZoomSlider {}
impl AVCaptureSystemZoomSlider {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSystemZoomSlider").unwrap(), alloc) })
    }
}
impl IAVCaptureControl for AVCaptureSystemZoomSlider {}
impl std::convert::TryFrom<AVCaptureControl> for AVCaptureSystemZoomSlider {
    type Error = &'static str;
    fn try_from(parent: AVCaptureControl) -> Result<AVCaptureSystemZoomSlider, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSystemZoomSlider").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureSystemZoomSlider(parent.0))
        } else {
            Err("This AVCaptureControl cannot be downcasted to AVCaptureSystemZoomSlider")
        }
    }
}
impl INSObject for AVCaptureSystemZoomSlider {}
impl PNSObject for AVCaptureSystemZoomSlider {}
impl IAVCaptureSystemZoomSlider for AVCaptureSystemZoomSlider {}
pub trait IAVCaptureSystemZoomSlider: Sized + std::ops::Deref {
    unsafe fn initWithDevice_(&self, device: AVCaptureDevice) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device)
    }
    unsafe fn initWithDevice_action_(
        &self,
        device: AVCaptureDevice,
        action: *mut ::std::os::raw::c_void,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithDevice : device, action : action)
    }
}
pub type AVCaptureTimecodeSourceType = NSInteger;
pub type AVCaptureTimecodeGeneratorSynchronizationStatus = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureTimecodeSource(pub id);
impl std::ops::Deref for AVCaptureTimecodeSource {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureTimecodeSource {}
impl AVCaptureTimecodeSource {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureTimecodeSource").unwrap(), alloc) })
    }
}
impl PNSCopying for AVCaptureTimecodeSource {}
impl INSObject for AVCaptureTimecodeSource {}
impl PNSObject for AVCaptureTimecodeSource {}
impl std::convert::TryFrom<NSObject> for AVCaptureTimecodeSource {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureTimecodeSource, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureTimecodeSource").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureTimecodeSource(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureTimecodeSource")
        }
    }
}
impl IAVCaptureTimecodeSource for AVCaptureTimecodeSource {}
pub trait IAVCaptureTimecodeSource: Sized + std::ops::Deref {
    unsafe fn displayName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayName)
    }
    unsafe fn type_(&self) -> AVCaptureTimecodeSourceType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, type)
    }
    unsafe fn uuid(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uuid)
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureTimecode {
    pub hours: u8,
    pub minutes: u8,
    pub seconds: u8,
    pub frames: u8,
    pub userBits: u32,
    pub frameDuration: CMTime,
    pub sourceType: AVCaptureTimecodeSourceType,
}
pub trait PAVCaptureTimecodeGeneratorDelegate: Sized + std::ops::Deref {
    unsafe fn timecodeGenerator_didReceiveUpdate_fromSource_(
        &self,
        generator: AVCaptureTimecodeGenerator,
        timecode: AVCaptureTimecode,
        source: AVCaptureTimecodeSource,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, timecodeGenerator : generator, didReceiveUpdate : timecode, fromSource : source)
    }
    unsafe fn timecodeGenerator_transitionedToSynchronizationStatus_forSource_(
        &self,
        generator: AVCaptureTimecodeGenerator,
        synchronizationStatus: AVCaptureTimecodeGeneratorSynchronizationStatus,
        source: AVCaptureTimecodeSource,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, timecodeGenerator : generator, transitionedToSynchronizationStatus : synchronizationStatus, forSource : source)
    }
    unsafe fn timecodeGenerator_didUpdateAvailableSources_(
        &self,
        generator: AVCaptureTimecodeGenerator,
        availableSources: NSArray,
    ) where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, timecodeGenerator : generator, didUpdateAvailableSources : availableSources)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureTimecodeGenerator(pub id);
impl std::ops::Deref for AVCaptureTimecodeGenerator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureTimecodeGenerator {}
impl AVCaptureTimecodeGenerator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureTimecodeGenerator").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureTimecodeGenerator {}
impl PNSObject for AVCaptureTimecodeGenerator {}
impl std::convert::TryFrom<NSObject> for AVCaptureTimecodeGenerator {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVCaptureTimecodeGenerator, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureTimecodeGenerator").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureTimecodeGenerator(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVCaptureTimecodeGenerator")
        }
    }
}
impl IAVCaptureTimecodeGenerator for AVCaptureTimecodeGenerator {}
pub trait IAVCaptureTimecodeGenerator: Sized + std::ops::Deref {
    unsafe fn setDelegate_queue_(&self, delegate: *mut u64, callbackQueue: NSObject)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDelegate : delegate, queue : callbackQueue)
    }
    unsafe fn startSynchronizationWithTimecodeSource_(&self, source: AVCaptureTimecodeSource)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, startSynchronizationWithTimecodeSource : source)
    }
    unsafe fn generateInitialTimecode(&self) -> AVCaptureTimecode
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, generateInitialTimecode)
    }
    unsafe fn availableSources(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableSources)
    }
    unsafe fn currentSource(&self) -> AVCaptureTimecodeSource
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, currentSource)
    }
    unsafe fn delegate(&self) -> *mut u64
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegate)
    }
    unsafe fn delegateCallbackQueue(&self) -> dispatch_queue_t
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, delegateCallbackQueue)
    }
    unsafe fn synchronizationTimeout(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, synchronizationTimeout)
    }
    unsafe fn setSynchronizationTimeout_(&self, synchronizationTimeout: NSTimeInterval)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSynchronizationTimeout : synchronizationTimeout)
    }
    unsafe fn timecodeAlignmentOffset(&self) -> NSTimeInterval
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timecodeAlignmentOffset)
    }
    unsafe fn setTimecodeAlignmentOffset_(&self, timecodeAlignmentOffset: NSTimeInterval)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimecodeAlignmentOffset : timecodeAlignmentOffset)
    }
    unsafe fn timecodeFrameDuration(&self) -> CMTime
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timecodeFrameDuration)
    }
    unsafe fn setTimecodeFrameDuration_(&self, timecodeFrameDuration: CMTime)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setTimecodeFrameDuration : timecodeFrameDuration)
    }
    unsafe fn frameCountSource() -> AVCaptureTimecodeSource
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureTimecodeGenerator").unwrap(), frameCountSource)
    }
    unsafe fn realTimeClockSource() -> AVCaptureTimecodeSource
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureTimecodeGenerator").unwrap(), realTimeClockSource)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureVideoPreviewLayer(pub id);
impl std::ops::Deref for AVCaptureVideoPreviewLayer {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureVideoPreviewLayer {}
impl AVCaptureVideoPreviewLayer {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureVideoPreviewLayer").unwrap(), alloc) })
    }
}
impl ICALayer for AVCaptureVideoPreviewLayer {}
impl PNSSecureCoding for AVCaptureVideoPreviewLayer {}
impl PCAMediaTiming for AVCaptureVideoPreviewLayer {}
impl std::convert::TryFrom<CALayer> for AVCaptureVideoPreviewLayer {
    type Error = &'static str;
    fn try_from(parent: CALayer) -> Result<AVCaptureVideoPreviewLayer, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureVideoPreviewLayer").unwrap()) };
        if is_kind_of {
            Ok(AVCaptureVideoPreviewLayer(parent.0))
        } else {
            Err("This CALayer cannot be downcasted to AVCaptureVideoPreviewLayer")
        }
    }
}
impl INSObject for AVCaptureVideoPreviewLayer {}
impl PNSObject for AVCaptureVideoPreviewLayer {}
impl IAVCaptureVideoPreviewLayer for AVCaptureVideoPreviewLayer {}
pub trait IAVCaptureVideoPreviewLayer: Sized + std::ops::Deref {
    unsafe fn initWithSession_(&self, session: AVCaptureSession) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithSession : session)
    }
    unsafe fn initWithSessionWithNoConnection_(&self, session: AVCaptureSession) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, initWithSessionWithNoConnection : session)
    }
    unsafe fn setSessionWithNoConnection_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSessionWithNoConnection : session)
    }
    unsafe fn captureDevicePointOfInterestForPoint_(&self, pointInLayer: CGPoint) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, captureDevicePointOfInterestForPoint : pointInLayer)
    }
    unsafe fn pointForCaptureDevicePointOfInterest_(
        &self,
        captureDevicePointOfInterest: CGPoint,
    ) -> CGPoint
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, pointForCaptureDevicePointOfInterest : captureDevicePointOfInterest)
    }
    unsafe fn metadataOutputRectOfInterestForRect_(&self, rectInLayerCoordinates: CGRect) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, metadataOutputRectOfInterestForRect : rectInLayerCoordinates)
    }
    unsafe fn rectForMetadataOutputRectOfInterest_(
        &self,
        rectInMetadataOutputCoordinates: CGRect,
    ) -> CGRect
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, rectForMetadataOutputRectOfInterest : rectInMetadataOutputCoordinates)
    }
    unsafe fn transformedMetadataObjectForMetadataObject_(
        &self,
        metadataObject: AVMetadataObject,
    ) -> AVMetadataObject
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, transformedMetadataObjectForMetadataObject : metadataObject)
    }
    unsafe fn session(&self) -> AVCaptureSession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, session)
    }
    unsafe fn setSession_(&self, session: AVCaptureSession)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setSession : session)
    }
    unsafe fn connection(&self) -> AVCaptureConnection
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, connection)
    }
    unsafe fn videoGravity(&self) -> AVLayerVideoGravity
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoGravity)
    }
    unsafe fn setVideoGravity_(&self, videoGravity: NSString)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setVideoGravity : videoGravity)
    }
    unsafe fn isPreviewing(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isPreviewing)
    }
    unsafe fn isOrientationSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isOrientationSupported)
    }
    unsafe fn orientation(&self) -> AVCaptureVideoOrientation
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, orientation)
    }
    unsafe fn setOrientation_(&self, orientation: AVCaptureVideoOrientation)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setOrientation : orientation)
    }
    unsafe fn isMirroringSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMirroringSupported)
    }
    unsafe fn automaticallyAdjustsMirroring(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, automaticallyAdjustsMirroring)
    }
    unsafe fn setAutomaticallyAdjustsMirroring_(&self, automaticallyAdjustsMirroring: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setAutomaticallyAdjustsMirroring : automaticallyAdjustsMirroring)
    }
    unsafe fn isMirrored(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isMirrored)
    }
    unsafe fn setMirrored_(&self, mirrored: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setMirrored : mirrored)
    }
    unsafe fn isDeferredStartSupported(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDeferredStartSupported)
    }
    unsafe fn isDeferredStartEnabled(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDeferredStartEnabled)
    }
    unsafe fn setDeferredStartEnabled_(&self, deferredStartEnabled: BOOL)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, setDeferredStartEnabled : deferredStartEnabled)
    }
    unsafe fn layerWithSession_(session: AVCaptureSession) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureVideoPreviewLayer").unwrap(), layerWithSession : session)
    }
    unsafe fn layerWithSessionWithNoConnection_(session: AVCaptureSession) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureVideoPreviewLayer").unwrap(), layerWithSessionWithNoConnection : session)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVContinuityDevice(pub id);
impl std::ops::Deref for AVContinuityDevice {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVContinuityDevice {}
impl AVContinuityDevice {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVContinuityDevice").unwrap(), alloc) })
    }
}
impl INSObject for AVContinuityDevice {}
impl PNSObject for AVContinuityDevice {}
impl std::convert::TryFrom<NSObject> for AVContinuityDevice {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVContinuityDevice, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVContinuityDevice").unwrap()) };
        if is_kind_of {
            Ok(AVContinuityDevice(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVContinuityDevice")
        }
    }
}
impl IAVContinuityDevice for AVContinuityDevice {}
pub trait IAVContinuityDevice: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn connectionID(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, connectionID)
    }
    unsafe fn isConnected(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConnected)
    }
    unsafe fn videoDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, videoDevices)
    }
    unsafe fn audioSessionInputs(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, audioSessionInputs)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVContinuityDevice").unwrap(), new)
    }
}
pub type AVDepthDataQuality = NSInteger;
pub type AVDepthDataAccuracy = NSInteger;
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVDepthData(pub id);
impl std::ops::Deref for AVDepthData {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVDepthData {}
impl AVDepthData {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVDepthData").unwrap(), alloc) })
    }
}
impl INSObject for AVDepthData {}
impl PNSObject for AVDepthData {}
impl std::convert::TryFrom<NSObject> for AVDepthData {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVDepthData, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVDepthData").unwrap()) };
        if is_kind_of {
            Ok(AVDepthData(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVDepthData")
        }
    }
}
impl IAVDepthData for AVDepthData {}
pub trait IAVDepthData: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn depthDataByConvertingToDepthDataType_(&self, depthDataType: OSType) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, depthDataByConvertingToDepthDataType : depthDataType)
    }
    unsafe fn depthDataByApplyingExifOrientation_(
        &self,
        exifOrientation: CGImagePropertyOrientation,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, depthDataByApplyingExifOrientation : exifOrientation)
    }
    unsafe fn depthDataByReplacingDepthDataMapWithPixelBuffer_error_(
        &self,
        pixelBuffer: CVPixelBufferRef,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, depthDataByReplacingDepthDataMapWithPixelBuffer : pixelBuffer, error : outError)
    }
    unsafe fn dictionaryRepresentationForAuxiliaryDataType_(
        &self,
        outAuxDataType: *mut NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dictionaryRepresentationForAuxiliaryDataType : outAuxDataType)
    }
    unsafe fn availableDepthDataTypes(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, availableDepthDataTypes)
    }
    unsafe fn depthDataType(&self) -> OSType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthDataType)
    }
    unsafe fn depthDataMap(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthDataMap)
    }
    unsafe fn depthDataQuality(&self) -> AVDepthDataQuality
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthDataQuality)
    }
    unsafe fn isDepthDataFiltered(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isDepthDataFiltered)
    }
    unsafe fn depthDataAccuracy(&self) -> AVDepthDataAccuracy
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, depthDataAccuracy)
    }
    unsafe fn cameraCalibrationData(&self) -> AVCameraCalibrationData
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, cameraCalibrationData)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDepthData").unwrap(), new)
    }
    unsafe fn depthDataFromDictionaryRepresentation_error_(
        imageSourceAuxDataInfoDictionary: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVDepthData").unwrap(), depthDataFromDictionaryRepresentation : imageSourceAuxDataInfoDictionary, error : outError)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVExternalStorageDevice(pub id);
impl std::ops::Deref for AVExternalStorageDevice {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVExternalStorageDevice {}
impl AVExternalStorageDevice {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDevice").unwrap(), alloc) })
    }
}
impl INSObject for AVExternalStorageDevice {}
impl PNSObject for AVExternalStorageDevice {}
impl std::convert::TryFrom<NSObject> for AVExternalStorageDevice {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVExternalStorageDevice, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVExternalStorageDevice").unwrap()) };
        if is_kind_of {
            Ok(AVExternalStorageDevice(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVExternalStorageDevice")
        }
    }
}
impl IAVExternalStorageDevice for AVExternalStorageDevice {}
pub trait IAVExternalStorageDevice: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn nextAvailableURLsWithPathExtensions_error_(
        &self,
        extensionArray: NSArray,
        outError: *mut NSError,
    ) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, nextAvailableURLsWithPathExtensions : extensionArray, error : outError)
    }
    unsafe fn displayName(&self) -> NSString
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, displayName)
    }
    unsafe fn freeSize(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, freeSize)
    }
    unsafe fn totalSize(&self) -> NSInteger
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, totalSize)
    }
    unsafe fn isConnected(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isConnected)
    }
    unsafe fn uuid(&self) -> NSUUID
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, uuid)
    }
    unsafe fn isNotRecommendedForCaptureUse(&self) -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, isNotRecommendedForCaptureUse)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDevice").unwrap(), new)
    }
}
impl AVExternalStorageDevice_AVExternalStorageDeviceAuthorization for AVExternalStorageDevice {}
pub trait AVExternalStorageDevice_AVExternalStorageDeviceAuthorization:
    Sized + std::ops::Deref
{
    unsafe fn requestAccessWithCompletionHandler_(handler: *mut ::std::os::raw::c_void)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDevice").unwrap(), requestAccessWithCompletionHandler : handler)
    }
    unsafe fn authorizationStatus() -> AVAuthorizationStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDevice").unwrap(), authorizationStatus)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVExternalStorageDeviceDiscoverySession(pub id);
impl std::ops::Deref for AVExternalStorageDeviceDiscoverySession {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVExternalStorageDeviceDiscoverySession {}
impl AVExternalStorageDeviceDiscoverySession {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDeviceDiscoverySession").unwrap(), alloc) })
    }
}
impl INSObject for AVExternalStorageDeviceDiscoverySession {}
impl PNSObject for AVExternalStorageDeviceDiscoverySession {}
impl std::convert::TryFrom<NSObject> for AVExternalStorageDeviceDiscoverySession {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVExternalStorageDeviceDiscoverySession, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVExternalStorageDeviceDiscoverySession").unwrap())
        };
        if is_kind_of {
            Ok(AVExternalStorageDeviceDiscoverySession(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVExternalStorageDeviceDiscoverySession")
        }
    }
}
impl IAVExternalStorageDeviceDiscoverySession for AVExternalStorageDeviceDiscoverySession {}
pub trait IAVExternalStorageDeviceDiscoverySession: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn externalStorageDevices(&self) -> NSArray
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, externalStorageDevices)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDeviceDiscoverySession").unwrap(), new)
    }
    unsafe fn sharedSession() -> AVExternalStorageDeviceDiscoverySession
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDeviceDiscoverySession").unwrap(), sharedSession)
    }
    unsafe fn isSupported() -> BOOL
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVExternalStorageDeviceDiscoverySession").unwrap(), isSupported)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVPortraitEffectsMatte(pub id);
impl std::ops::Deref for AVPortraitEffectsMatte {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVPortraitEffectsMatte {}
impl AVPortraitEffectsMatte {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVPortraitEffectsMatte").unwrap(), alloc) })
    }
}
impl INSObject for AVPortraitEffectsMatte {}
impl PNSObject for AVPortraitEffectsMatte {}
impl std::convert::TryFrom<NSObject> for AVPortraitEffectsMatte {
    type Error = &'static str;
    fn try_from(parent: NSObject) -> Result<AVPortraitEffectsMatte, Self::Error> {
        let is_kind_of: bool =
            unsafe { msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVPortraitEffectsMatte").unwrap()) };
        if is_kind_of {
            Ok(AVPortraitEffectsMatte(parent.0))
        } else {
            Err("This NSObject cannot be downcasted to AVPortraitEffectsMatte")
        }
    }
}
impl IAVPortraitEffectsMatte for AVPortraitEffectsMatte {}
pub trait IAVPortraitEffectsMatte: Sized + std::ops::Deref {
    unsafe fn init(&self) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, init)
    }
    unsafe fn portraitEffectsMatteByApplyingExifOrientation_(
        &self,
        exifOrientation: CGImagePropertyOrientation,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, portraitEffectsMatteByApplyingExifOrientation : exifOrientation)
    }
    unsafe fn portraitEffectsMatteByReplacingPortraitEffectsMatteWithPixelBuffer_error_(
        &self,
        pixelBuffer: CVPixelBufferRef,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, portraitEffectsMatteByReplacingPortraitEffectsMatteWithPixelBuffer : pixelBuffer, error : outError)
    }
    unsafe fn dictionaryRepresentationForAuxiliaryDataType_(
        &self,
        outAuxDataType: *mut NSString,
    ) -> NSDictionary
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, dictionaryRepresentationForAuxiliaryDataType : outAuxDataType)
    }
    unsafe fn pixelFormatType(&self) -> OSType
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, pixelFormatType)
    }
    unsafe fn mattingImage(&self) -> CVPixelBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, mattingImage)
    }
    unsafe fn new() -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPortraitEffectsMatte").unwrap(), new)
    }
    unsafe fn portraitEffectsMatteFromDictionaryRepresentation_error_(
        imageSourceAuxDataInfoDictionary: NSDictionary,
        outError: *mut NSError,
    ) -> instancetype
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&*objc2::runtime::AnyClass::get(c"AVPortraitEffectsMatte").unwrap(), portraitEffectsMatteFromDictionaryRepresentation : imageSourceAuxDataInfoDictionary, error : outError)
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone)]
pub struct AVCaptureSpatialAudioMetadataSampleGenerator(pub id);
impl std::ops::Deref for AVCaptureSpatialAudioMetadataSampleGenerator {
    type Target = objc2::runtime::AnyObject;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.0 }
    }
}
unsafe impl objc2::Message for AVCaptureSpatialAudioMetadataSampleGenerator {}
impl AVCaptureSpatialAudioMetadataSampleGenerator {
    pub fn alloc() -> Self {
        Self(unsafe { msg_send!(&*objc2::runtime::AnyClass::get(c"AVCaptureSpatialAudioMetadataSampleGenerator").unwrap(), alloc) })
    }
}
impl INSObject for AVCaptureSpatialAudioMetadataSampleGenerator {}
impl PNSObject for AVCaptureSpatialAudioMetadataSampleGenerator {}
impl std::convert::TryFrom<NSObject> for AVCaptureSpatialAudioMetadataSampleGenerator {
    type Error = &'static str;
    fn try_from(
        parent: NSObject,
    ) -> Result<AVCaptureSpatialAudioMetadataSampleGenerator, Self::Error> {
        let is_kind_of: bool = unsafe {
            msg_send!(&*parent, isKindOfClass : objc2::runtime::AnyClass::get(c"AVCaptureSpatialAudioMetadataSampleGenerator").unwrap())
        };
        if is_kind_of {
            Ok(AVCaptureSpatialAudioMetadataSampleGenerator(parent.0))
        } else {
            Err ("This NSObject cannot be downcasted to AVCaptureSpatialAudioMetadataSampleGenerator" ,)
        }
    }
}
impl IAVCaptureSpatialAudioMetadataSampleGenerator
    for AVCaptureSpatialAudioMetadataSampleGenerator
{
}
pub trait IAVCaptureSpatialAudioMetadataSampleGenerator: Sized + std::ops::Deref {
    unsafe fn analyzeAudioSample_(&self, sbuf: CMSampleBufferRef) -> OSStatus
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&** self, analyzeAudioSample : sbuf)
    }
    unsafe fn newTimedMetadataSampleBufferAndResetAnalyzer(&self) -> CMSampleBufferRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, newTimedMetadataSampleBufferAndResetAnalyzer)
    }
    unsafe fn resetAnalyzer(&self)
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, resetAnalyzer)
    }
    unsafe fn timedMetadataSampleBufferFormatDescription(&self) -> CMFormatDescriptionRef
    where
        <Self as std::ops::Deref>::Target: objc2::Message + Sized,
    {
        msg_send!(&**self, timedMetadataSampleBufferFormatDescription)
    }
}
unsafe extern "C" {
    pub static AVFoundationErrorDomain: NSErrorDomain;
}

unsafe impl objc2::encode::RefEncode for simd_float3x3 {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for simd_float3x3 {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("simd_float3x3", &[]);
}
unsafe impl objc2::encode::RefEncode for simd_float4x3 {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for simd_float4x3 {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("simd_float4x3", &[]);
}
unsafe impl objc2::encode::RefEncode for AVContentKeySession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContentKeySession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVContentKeyRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContentKeyRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPersistableContentKeyRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPersistableContentKeyRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVContentKeyResponse {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContentKeyResponse {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVContentKeySpecifier {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContentKeySpecifier {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVContentKey {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContentKey {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariant {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariant {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariantVideoAttributes {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariantVideoAttributes {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariantVideoLayoutAttributes {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariantVideoLayoutAttributes {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariantAudioAttributes {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariantAudioAttributes {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariantAudioRenditionSpecificAttributes {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariantAudioRenditionSpecificAttributes {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetVariantQualifier {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetVariantQualifier {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDisplayCriteria {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDisplayCriteria {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAsset {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAsset {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVURLAsset {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVURLAsset {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaExtensionProperties {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaExtensionProperties {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedAsset {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedAsset {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedAssetMinder {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedAssetMinder {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetCache {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetCache {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetExportSession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetExportSession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetImageGenerator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetImageGenerator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReader {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReader {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVTimedMetadataGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVTimedMetadataGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableTimedMetadataGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableTimedMetadataGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDateRangeMetadataGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDateRangeMetadataGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableDateRangeMetadataGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableDateRangeMetadataGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSpatialVideoConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSpatialVideoConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPixelAspectRatio {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPixelAspectRatio {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVPixelAspectRatio", &[]);
}
unsafe impl objc2::encode::RefEncode for AVEdgeWidths {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVEdgeWidths {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVEdgeWidths", &[]);
}
unsafe impl objc2::encode::RefEncode for AVVideoCompositionRenderContext {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoCompositionRenderContext {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoCompositionRenderHint {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoCompositionRenderHint {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAsynchronousVideoCompositionRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAsynchronousVideoCompositionRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAsynchronousCIImageFilteringRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAsynchronousCIImageFilteringRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoComposition {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoComposition {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableVideoComposition {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableVideoComposition {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoCompositionInstruction {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoCompositionInstruction {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableVideoCompositionInstruction {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableVideoCompositionInstruction {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoCompositionLayerInstruction {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoCompositionLayerInstruction {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableVideoCompositionLayerInstruction {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableVideoCompositionLayerInstruction {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoCompositionCoreAnimationTool {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoCompositionCoreAnimationTool {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderTrackOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderTrackOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderAudioMixOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderAudioMixOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderVideoCompositionOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderVideoCompositionOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderOutputMetadataAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderOutputMetadataAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderOutputCaptionAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderOutputCaptionAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetReaderSampleReferenceOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetReaderSampleReferenceOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceLoader {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceLoader {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceLoadingRequestor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceLoadingRequestor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceLoadingRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceLoadingRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceRenewalRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceRenewalRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceLoadingContentInformationRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceLoadingContentInformationRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetResourceLoadingDataRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetResourceLoadingDataRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetTrackSegment {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetTrackSegment {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedAssetTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedAssetTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetTrackGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetTrackGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaSelectionGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaSelectionGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaSelectionOption {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaSelectionOption {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCustomMediaSelectionScheme {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCustomMediaSelectionScheme {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaPresentationSelector {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaPresentationSelector {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaPresentationSetting {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaPresentationSetting {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetSegmentReport {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetSegmentReport {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetSegmentTrackReport {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetSegmentTrackReport {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetSegmentReportSampleInformation {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetSegmentReportSampleInformation {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriter {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriter {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputPassDescription {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputPassDescription {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputPixelBufferAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputPixelBufferAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputTaggedPixelBufferGroupAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputMetadataAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputMetadataAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetWriterInputCaptionAdaptor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetWriterInputCaptionAdaptor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetPlaybackAssistant {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetPlaybackAssistant {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAudioMix {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAudioMix {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableAudioMix {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableAudioMix {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAudioMixInputParameters {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAudioMixInputParameters {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableAudioMixInputParameters {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableAudioMixInputParameters {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaSelection {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaSelection {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableMediaSelection {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableMediaSelection {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricEventStream {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricEventStream {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricErrorEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricErrorEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricMediaResourceRequestEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricMediaResourceRequestEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricHLSPlaylistRequestEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricHLSPlaylistRequestEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricHLSMediaSegmentRequestEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricHLSMediaSegmentRequestEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricContentKeyRequestEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricContentKeyRequestEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemLikelyToKeepUpEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemLikelyToKeepUpEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemInitialLikelyToKeepUpEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemInitialLikelyToKeepUpEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemRateChangeEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemRateChangeEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemStallEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemStallEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemSeekEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemSeekEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemSeekDidCompleteEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemSeekDidCompleteEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricMediaRendition {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricMediaRendition {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemVariantSwitchEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemVariantSwitchEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemVariantSwitchStartEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemVariantSwitchStartEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricPlayerItemPlaybackSummaryEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricPlayerItemPlaybackSummaryEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetricDownloadSummaryEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetricDownloadSummaryEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerMediaSelectionCriteria {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerMediaSelectionCriteria {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadTask {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadTask {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadContentConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadContentConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAggregateAssetDownloadTask {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAggregateAssetDownloadTask {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadURLSession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadURLSession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadStorageManager {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadStorageManager {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVAssetDownloadStorageManagementPolicy {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVAssetDownloadStorageManagementPolicy {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableAssetDownloadStorageManagementPolicy {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableAssetDownloadStorageManagementPolicy {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionDimension {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionDimension {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptionDimension", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptionPoint {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionPoint {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptionPoint", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptionSize {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionSize {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptionSize", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptionRegion {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionRegion {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableCaptionRegion {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableCaptionRegion {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaption {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaption {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableCaption {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableCaption {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionRuby {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionRuby {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionGroup {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionGroup {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionGrouper {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionGrouper {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionConversionValidator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionConversionValidator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionConversionWarning {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionConversionWarning {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionConversionAdjustment {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionConversionAdjustment {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionConversionTimeRangeAdjustment {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionConversionTimeRangeAdjustment {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionFormatConformer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionFormatConformer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVTextStyleRule {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVTextStyleRule {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionRenderer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionRenderer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptionRendererScene {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptionRendererScene {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCompositionTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCompositionTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableCompositionTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableCompositionTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCompositionTrackFormatDescriptionReplacement {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCompositionTrackFormatDescriptionReplacement {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVComposition {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVComposition {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableComposition {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableComposition {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCompositionTrackSegment {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCompositionTrackSegment {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataItem {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataItem {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableMetadataItem {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableMetadataItem {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataItemValueRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataItemValueRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataItemFilter {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataItemFilter {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMovieTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMovieTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableMovieTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableMovieTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedMovieTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedMovieTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMovie {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMovie {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMutableMovie {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMutableMovie {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMediaDataStorage {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMediaDataStorage {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedMovie {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedMovie {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFragmentedMovieMinder {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFragmentedMovieMinder {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVOutputSettingsAssistant {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVOutputSettingsAssistant {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVQueuePlayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVQueuePlayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlaybackCoordinationMedium {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlaybackCoordinationMedium {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCoordinatedPlaybackSuspension {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCoordinatedPlaybackSuspension {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlaybackCoordinator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlaybackCoordinator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCoordinatedPlaybackParticipant {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCoordinatedPlaybackParticipant {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerPlaybackCoordinator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerPlaybackCoordinator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinatorPlaybackControlCommand {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinatorPlayCommand {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinatorPlayCommand {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinatorBufferingCommand {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinatorBufferingCommand {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinatorPauseCommand {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinatorPauseCommand {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDelegatingPlaybackCoordinatorSeekCommand {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDelegatingPlaybackCoordinatorSeekCommand {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerVideoOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerVideoOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoOutputSpecification {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoOutputSpecification {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerVideoOutputConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerVideoOutputConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItem {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItem {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemAccessLog {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemAccessLog {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemErrorLog {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemErrorLog {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemAccessLogEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemAccessLogEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemErrorLogEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemErrorLogEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemMediaDataCollector {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemMediaDataCollector {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemMetadataCollector {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemMetadataCollector {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemVideoOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemVideoOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemLegibleOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemLegibleOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemMetadataOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemMetadataOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemRenderedLegibleOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemRenderedLegibleOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemTrack {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemTrack {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerLayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerLayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerLooper {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerLooper {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerInterstitialEvent {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerInterstitialEvent {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerInterstitialEventMonitor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerInterstitialEventMonitor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerInterstitialEventController {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerInterstitialEventController {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemSegment {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemSegment {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemIntegratedTimelineSnapshot {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemIntegratedTimelineSnapshot {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPlayerItemIntegratedTimeline {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPlayerItemIntegratedTimeline {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVRenderedCaptionImage {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVRenderedCaptionImage {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVRouteDetector {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVRouteDetector {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferAudioRenderer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferAudioRenderer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferDisplayLayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferDisplayLayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferRenderSynchronizer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferRenderSynchronizer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleCursor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleCursorSyncInfo {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursorSyncInfo {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVSampleCursorSyncInfo", &[]);
}
unsafe impl objc2::encode::RefEncode for AVSampleCursorDependencyInfo {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursorDependencyInfo {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVSampleCursorDependencyInfo", &[]);
}
unsafe impl objc2::encode::RefEncode for AVSampleCursorAudioDependencyInfo {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursorAudioDependencyInfo {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVSampleCursorAudioDependencyInfo", &[]);
}
unsafe impl objc2::encode::RefEncode for AVSampleCursorStorageRange {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursorStorageRange {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVSampleCursorStorageRange", &[]);
}
unsafe impl objc2::encode::RefEncode for AVSampleCursorChunkInfo {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleCursorChunkInfo {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVSampleCursorChunkInfo", &[]);
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferGenerator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferGenerator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferRequest {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferRequest {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferGeneratorBatch {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferGeneratorBatch {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSampleBufferVideoRenderer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSampleBufferVideoRenderer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSynchronizedLayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSynchronizedLayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVVideoPerformanceMetrics {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVVideoPerformanceMetrics {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCameraCalibrationData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCameraCalibrationData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureReactionEffectState {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureReactionEffectState {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDevice {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDevice {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureWhiteBalanceGains {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureWhiteBalanceGains {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptureWhiteBalanceGains", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptureWhiteBalanceChromaticityValues {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureWhiteBalanceChromaticityValues {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptureWhiteBalanceChromaticityValues", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptureWhiteBalanceTemperatureAndTintValues {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureWhiteBalanceTemperatureAndTintValues {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptureWhiteBalanceTemperatureAndTintValues", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptureSmartFramingMonitor {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSmartFramingMonitor {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureFraming {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureFraming {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeviceDiscoverySession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeviceDiscoverySession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeviceRotationCoordinator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeviceRotationCoordinator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVExposureBiasRange {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVExposureBiasRange {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVFrameRateRange {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVFrameRateRange {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVZoomRange {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVZoomRange {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeviceFormat {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeviceFormat {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeviceInputSource {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeviceInputSource {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureMultiCamSession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureMultiCamSession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureConnection {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureConnection {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureAudioChannel {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureAudioChannel {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureAudioDataOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureAudioDataOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureAudioPreviewOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureAudioPreviewOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureControl {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureControl {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDepthDataOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDepthDataOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureFileOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureFileOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureMovieFileOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureMovieFileOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureAudioFileOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureAudioFileOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataBodyObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataBodyObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataHumanBodyObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataHumanBodyObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataHumanFullBodyObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataHumanFullBodyObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataCatHeadObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataCatHeadObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataCatBodyObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataCatBodyObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataDogHeadObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataDogHeadObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataDogBodyObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataDogBodyObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataSalientObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataSalientObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataFaceObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataFaceObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVMetadataMachineReadableCodeObject {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVMetadataMachineReadableCodeObject {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureMetadataOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureMetadataOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVSemanticSegmentationMatte {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVSemanticSegmentationMatte {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCapturePhotoOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCapturePhotoOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCapturePhotoOutputReadinessCoordinator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCapturePhotoOutputReadinessCoordinator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCapturePhotoSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCapturePhotoSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCapturePhotoBracketSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCapturePhotoBracketSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureResolvedPhotoSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureResolvedPhotoSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCapturePhoto {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCapturePhoto {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeferredPhotoProxy {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeferredPhotoProxy {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureStillImageOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureStillImageOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureBracketedStillImageSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureBracketedStillImageSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureManualExposureBracketedStillImageSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureManualExposureBracketedStillImageSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureAutoExposureBracketedStillImageSettings {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureAutoExposureBracketedStillImageSettings {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureVideoDataOutput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureVideoDataOutput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDataOutputSynchronizer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDataOutputSynchronizer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSynchronizedDataCollection {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSynchronizedDataCollection {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSynchronizedData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSynchronizedData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSynchronizedSampleBufferData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSynchronizedSampleBufferData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSynchronizedMetadataObjectData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSynchronizedMetadataObjectData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSynchronizedDepthData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSynchronizedDepthData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeskViewApplication {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeskViewApplication {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeskViewApplicationLaunchConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeskViewApplicationLaunchConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureExternalDisplayConfiguration {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureExternalDisplayConfiguration {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureExternalDisplayConfigurator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureExternalDisplayConfigurator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureIndexPicker {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureIndexPicker {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVExternalSyncDevice {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVExternalSyncDevice {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVExternalSyncDeviceDiscoverySession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVExternalSyncDeviceDiscoverySession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureInput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureInput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureInputPort {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureInputPort {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureDeviceInput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureDeviceInput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureScreenInput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureScreenInput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureMetadataInput {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureMetadataInput {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSlider {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSlider {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSystemExposureBiasSlider {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSystemExposureBiasSlider {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSystemPressureState {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSystemPressureState {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSystemZoomSlider {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSystemZoomSlider {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureTimecodeSource {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureTimecodeSource {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureTimecode {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureTimecode {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Struct("AVCaptureTimecode", &[]);
}
unsafe impl objc2::encode::RefEncode for AVCaptureTimecodeGenerator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureTimecodeGenerator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureVideoPreviewLayer {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureVideoPreviewLayer {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVContinuityDevice {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVContinuityDevice {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVDepthData {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVDepthData {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVExternalStorageDevice {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVExternalStorageDevice {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVExternalStorageDeviceDiscoverySession {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVExternalStorageDeviceDiscoverySession {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVPortraitEffectsMatte {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVPortraitEffectsMatte {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
unsafe impl objc2::encode::RefEncode for AVCaptureSpatialAudioMetadataSampleGenerator {
    const ENCODING_REF: objc2::encode::Encoding = objc2::encode::Encoding::Pointer(&<Self as objc2::encode::Encode>::ENCODING);
}
unsafe impl objc2::encode::Encode for AVCaptureSpatialAudioMetadataSampleGenerator {
    const ENCODING: objc2::encode::Encoding = objc2::encode::Encoding::Object;
}
