//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-cloud-kit")]
use objc2_cloud_kit::*;
use objc2_foundation::*;

use crate::*;

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIStatusBarStyle(pub NSInteger);
impl UIStatusBarStyle {
    #[doc(alias = "UIStatusBarStyleDefault")]
    pub const Default: Self = Self(0);
    #[doc(alias = "UIStatusBarStyleLightContent")]
    pub const LightContent: Self = Self(1);
    #[doc(alias = "UIStatusBarStyleDarkContent")]
    pub const DarkContent: Self = Self(3);
    #[deprecated]
    #[doc(alias = "UIStatusBarStyleBlackTranslucent")]
    pub const BlackTranslucent: Self = Self(1);
    #[deprecated]
    #[doc(alias = "UIStatusBarStyleBlackOpaque")]
    pub const BlackOpaque: Self = Self(2);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIStatusBarAnimation(pub NSInteger);
impl UIStatusBarAnimation {
    #[doc(alias = "UIStatusBarAnimationNone")]
    pub const None: Self = Self(0);
    #[doc(alias = "UIStatusBarAnimationFade")]
    pub const Fade: Self = Self(1);
    #[doc(alias = "UIStatusBarAnimationSlide")]
    pub const Slide: Self = Self(2);
}

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

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

extern "C" {
    pub static UIApplicationInvalidInterfaceOrientationException: &'static NSExceptionName;
}

// NS_OPTIONS
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIRemoteNotificationType(pub NSUInteger);
bitflags::bitflags! {
    impl UIRemoteNotificationType: NSUInteger {
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
        #[doc(alias = "UIRemoteNotificationTypeNone")]
        const None = 0;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
        #[doc(alias = "UIRemoteNotificationTypeBadge")]
        const Badge = 1<<0;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
        #[doc(alias = "UIRemoteNotificationTypeSound")]
        const Sound = 1<<1;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
        #[doc(alias = "UIRemoteNotificationTypeAlert")]
        const Alert = 1<<2;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
        #[doc(alias = "UIRemoteNotificationTypeNewsstandContentAvailability")]
        const NewsstandContentAvailability = 1<<3;
    }
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIBackgroundFetchResult(pub NSUInteger);
impl UIBackgroundFetchResult {
    #[doc(alias = "UIBackgroundFetchResultNewData")]
    pub const NewData: Self = Self(0);
    #[doc(alias = "UIBackgroundFetchResultNoData")]
    pub const NoData: Self = Self(1);
    #[doc(alias = "UIBackgroundFetchResultFailed")]
    pub const Failed: Self = Self(2);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIBackgroundRefreshStatus(pub NSInteger);
impl UIBackgroundRefreshStatus {
    #[doc(alias = "UIBackgroundRefreshStatusRestricted")]
    pub const Restricted: Self = Self(0);
    #[doc(alias = "UIBackgroundRefreshStatusDenied")]
    pub const Denied: Self = Self(1);
    #[doc(alias = "UIBackgroundRefreshStatusAvailable")]
    pub const Available: Self = Self(2);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIApplicationState(pub NSInteger);
impl UIApplicationState {
    #[doc(alias = "UIApplicationStateActive")]
    pub const Active: Self = Self(0);
    #[doc(alias = "UIApplicationStateInactive")]
    pub const Inactive: Self = Self(1);
    #[doc(alias = "UIApplicationStateBackground")]
    pub const Background: Self = Self(2);
}

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

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

// NS_TYPED_ENUM
pub type UIBackgroundTaskIdentifier = NSUInteger;

extern "C" {
    pub static UIBackgroundTaskInvalid: UIBackgroundTaskIdentifier;
}

extern "C" {
    pub static UIMinimumKeepAliveTimeout: NSTimeInterval;
}

extern "C" {
    pub static UIApplicationBackgroundFetchIntervalMinimum: NSTimeInterval;
}

extern "C" {
    pub static UIApplicationBackgroundFetchIntervalNever: NSTimeInterval;
}

// NS_TYPED_ENUM
pub type UIApplicationOpenExternalURLOptionsKey = NSString;

extern_class!(
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "UIResponder")]
    pub struct UIApplication;

    #[cfg(feature = "UIResponder")]
    unsafe impl ClassType for UIApplication {
        #[inherits(NSObject)]
        type Super = UIResponder;
        type Mutability = MainThreadOnly;
    }
);

#[cfg(feature = "UIResponder")]
unsafe impl NSObjectProtocol for UIApplication {}

#[cfg(feature = "UIResponder")]
unsafe impl UIResponderStandardEditActions for UIApplication {}

extern_methods!(
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method_id(@__retain_semantics Other sharedApplication)]
        pub fn sharedApplication(mtm: MainThreadMarker) -> Retained<UIApplication>;

        #[method_id(@__retain_semantics Other delegate)]
        pub unsafe fn delegate(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn UIApplicationDelegate>>>;

        #[method(setDelegate:)]
        pub unsafe fn setDelegate(
            &self,
            delegate: Option<&ProtocolObject<dyn UIApplicationDelegate>>,
        );

        #[deprecated = "Use UIView's userInteractionEnabled property instead"]
        #[method(beginIgnoringInteractionEvents)]
        pub unsafe fn beginIgnoringInteractionEvents(&self);

        #[deprecated = "Use UIView's userInteractionEnabled property instead"]
        #[method(endIgnoringInteractionEvents)]
        pub unsafe fn endIgnoringInteractionEvents(&self);

        #[deprecated = "Use UIView's userInteractionEnabled property instead"]
        #[method(isIgnoringInteractionEvents)]
        pub unsafe fn isIgnoringInteractionEvents(&self) -> bool;

        #[method(isIdleTimerDisabled)]
        pub unsafe fn isIdleTimerDisabled(&self) -> bool;

        #[method(setIdleTimerDisabled:)]
        pub unsafe fn setIdleTimerDisabled(&self, idle_timer_disabled: bool);

        #[deprecated]
        #[method(openURL:)]
        pub unsafe fn openURL(&self, url: &NSURL) -> bool;

        #[method(canOpenURL:)]
        pub unsafe fn canOpenURL(&self, url: &NSURL) -> bool;

        #[cfg(feature = "block2")]
        #[method(openURL:options:completionHandler:)]
        pub unsafe fn openURL_options_completionHandler(
            &self,
            url: &NSURL,
            options: &NSDictionary<UIApplicationOpenExternalURLOptionsKey, AnyObject>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
        );

        #[cfg(feature = "UIEvent")]
        #[method(sendEvent:)]
        pub unsafe fn sendEvent(&self, event: &UIEvent);

        #[cfg(all(feature = "UIView", feature = "UIWindow"))]
        #[deprecated = "Should not be used for applications that support multiple scenes as it returns a key window across all connected scenes"]
        #[method_id(@__retain_semantics Other keyWindow)]
        pub unsafe fn keyWindow(&self) -> Option<Retained<UIWindow>>;

        #[cfg(all(feature = "UIView", feature = "UIWindow"))]
        #[deprecated = "Use UIWindowScene.windows on a relevant window scene instead"]
        #[method_id(@__retain_semantics Other windows)]
        pub fn windows(&self) -> Retained<NSArray<UIWindow>>;

        #[cfg(feature = "UIEvent")]
        #[method(sendAction:to:from:forEvent:)]
        pub unsafe fn sendAction_to_from_forEvent(
            &self,
            action: Sel,
            target: Option<&AnyObject>,
            sender: Option<&AnyObject>,
            event: Option<&UIEvent>,
        ) -> bool;

        #[deprecated = "Provide a custom network activity UI in your app if desired."]
        #[method(isNetworkActivityIndicatorVisible)]
        pub unsafe fn isNetworkActivityIndicatorVisible(&self) -> bool;

        #[deprecated = "Provide a custom network activity UI in your app if desired."]
        #[method(setNetworkActivityIndicatorVisible:)]
        pub unsafe fn setNetworkActivityIndicatorVisible(
            &self,
            network_activity_indicator_visible: bool,
        );

        #[cfg(all(feature = "UIOrientation", feature = "UIView", feature = "UIWindow"))]
        #[method(supportedInterfaceOrientationsForWindow:)]
        pub unsafe fn supportedInterfaceOrientationsForWindow(
            &self,
            window: Option<&UIWindow>,
        ) -> UIInterfaceOrientationMask;

        #[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
        #[method(statusBarOrientationAnimationDuration)]
        pub unsafe fn statusBarOrientationAnimationDuration(&self) -> NSTimeInterval;

        #[deprecated = "Use the statusBarManager property of the window scene instead."]
        #[method(statusBarFrame)]
        pub fn statusBarFrame(&self) -> CGRect;

        #[deprecated = "Use -[UNUserNotificationCenter setBadgeCount:withCompletionHandler:] instead."]
        #[method(applicationIconBadgeNumber)]
        pub unsafe fn applicationIconBadgeNumber(&self) -> NSInteger;

        #[deprecated = "Use -[UNUserNotificationCenter setBadgeCount:withCompletionHandler:] instead."]
        #[method(setApplicationIconBadgeNumber:)]
        pub unsafe fn setApplicationIconBadgeNumber(
            &self,
            application_icon_badge_number: NSInteger,
        );

        #[method(applicationSupportsShakeToEdit)]
        pub unsafe fn applicationSupportsShakeToEdit(&self) -> bool;

        #[method(setApplicationSupportsShakeToEdit:)]
        pub unsafe fn setApplicationSupportsShakeToEdit(
            &self,
            application_supports_shake_to_edit: bool,
        );

        #[method(applicationState)]
        pub unsafe fn applicationState(&self) -> UIApplicationState;

        #[method(backgroundTimeRemaining)]
        pub unsafe fn backgroundTimeRemaining(&self) -> NSTimeInterval;

        #[cfg(feature = "block2")]
        #[method(beginBackgroundTaskWithExpirationHandler:)]
        pub unsafe fn beginBackgroundTaskWithExpirationHandler(
            &self,
            handler: Option<&block2::Block<dyn Fn()>>,
        ) -> UIBackgroundTaskIdentifier;

        #[cfg(feature = "block2")]
        #[method(beginBackgroundTaskWithName:expirationHandler:)]
        pub unsafe fn beginBackgroundTaskWithName_expirationHandler(
            &self,
            task_name: Option<&NSString>,
            handler: Option<&block2::Block<dyn Fn()>>,
        ) -> UIBackgroundTaskIdentifier;

        #[method(endBackgroundTask:)]
        pub unsafe fn endBackgroundTask(&self, identifier: UIBackgroundTaskIdentifier);

        #[deprecated = "Use a BGAppRefreshTask in the BackgroundTasks framework instead"]
        #[method(setMinimumBackgroundFetchInterval:)]
        pub unsafe fn setMinimumBackgroundFetchInterval(
            &self,
            minimum_background_fetch_interval: NSTimeInterval,
        );

        #[method(backgroundRefreshStatus)]
        pub unsafe fn backgroundRefreshStatus(&self) -> UIBackgroundRefreshStatus;

        #[method(isProtectedDataAvailable)]
        pub unsafe fn isProtectedDataAvailable(&self) -> bool;

        #[cfg(feature = "UIInterface")]
        #[method(userInterfaceLayoutDirection)]
        pub unsafe fn userInterfaceLayoutDirection(&self) -> UIUserInterfaceLayoutDirection;

        #[cfg(feature = "UIContentSizeCategory")]
        #[method_id(@__retain_semantics Other preferredContentSizeCategory)]
        pub unsafe fn preferredContentSizeCategory(&self) -> Retained<UIContentSizeCategory>;

        #[cfg(feature = "UIScene")]
        #[method_id(@__retain_semantics Other connectedScenes)]
        pub unsafe fn connectedScenes(&self) -> Retained<NSSet<UIScene>>;

        #[cfg(feature = "UISceneSession")]
        #[method_id(@__retain_semantics Other openSessions)]
        pub unsafe fn openSessions(&self) -> Retained<NSSet<UISceneSession>>;

        #[method(supportsMultipleScenes)]
        pub unsafe fn supportsMultipleScenes(&self) -> bool;

        #[cfg(all(feature = "UISceneSessionActivationRequest", feature = "block2"))]
        #[method(activateSceneSessionForRequest:errorHandler:)]
        pub unsafe fn activateSceneSessionForRequest_errorHandler(
            &self,
            request: &UISceneSessionActivationRequest,
            error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
        );

        #[cfg(all(
            feature = "UISceneOptions",
            feature = "UISceneSession",
            feature = "block2"
        ))]
        #[deprecated = "Please use activateSceneSessionForRequest:errorHandler:"]
        #[method(requestSceneSessionActivation:userActivity:options:errorHandler:)]
        pub unsafe fn requestSceneSessionActivation_userActivity_options_errorHandler(
            &self,
            scene_session: Option<&UISceneSession>,
            user_activity: Option<&NSUserActivity>,
            options: Option<&UISceneActivationRequestOptions>,
            error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
        );

        #[cfg(all(
            feature = "UISceneOptions",
            feature = "UISceneSession",
            feature = "block2"
        ))]
        #[method(requestSceneSessionDestruction:options:errorHandler:)]
        pub unsafe fn requestSceneSessionDestruction_options_errorHandler(
            &self,
            scene_session: &UISceneSession,
            options: Option<&UISceneDestructionRequestOptions>,
            error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
        );

        #[cfg(feature = "UISceneSession")]
        #[method(requestSceneSessionRefresh:)]
        pub unsafe fn requestSceneSessionRefresh(&self, scene_session: &UISceneSession);
    }
);

extern_methods!(
    /// Methods declared on superclass `NSObject`
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method_id(@__retain_semantics Init init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[method_id(@__retain_semantics New new)]
        pub unsafe fn new(mtm: MainThreadMarker) -> Retained<Self>;
    }
);

extern_methods!(
    /// UIRemoteNotifications
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method(registerForRemoteNotifications)]
        pub unsafe fn registerForRemoteNotifications(&self);

        #[method(unregisterForRemoteNotifications)]
        pub unsafe fn unregisterForRemoteNotifications(&self);

        #[method(isRegisteredForRemoteNotifications)]
        pub unsafe fn isRegisteredForRemoteNotifications(&self) -> bool;

        #[deprecated = "Use -[UIApplication registerForRemoteNotifications] and UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:]"]
        #[method(registerForRemoteNotificationTypes:)]
        pub unsafe fn registerForRemoteNotificationTypes(&self, types: UIRemoteNotificationType);

        #[deprecated = "Use -[UIApplication isRegisteredForRemoteNotifications] and UserNotifications Framework's -[UNUserNotificationCenter getNotificationSettingsWithCompletionHandler:] to retrieve user-enabled remote notification and user notification settings"]
        #[method(enabledRemoteNotificationTypes)]
        pub unsafe fn enabledRemoteNotificationTypes(&self) -> UIRemoteNotificationType;
    }
);

extern_methods!(
    /// UILocalNotifications
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[cfg(feature = "UILocalNotification")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter addNotificationRequest:withCompletionHandler:]"]
        #[method(presentLocalNotificationNow:)]
        pub unsafe fn presentLocalNotificationNow(&self, notification: &UILocalNotification);

        #[cfg(feature = "UILocalNotification")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter addNotificationRequest:withCompletionHandler:]"]
        #[method(scheduleLocalNotification:)]
        pub unsafe fn scheduleLocalNotification(&self, notification: &UILocalNotification);

        #[cfg(feature = "UILocalNotification")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter removePendingNotificationRequestsWithIdentifiers:]"]
        #[method(cancelLocalNotification:)]
        pub unsafe fn cancelLocalNotification(&self, notification: &UILocalNotification);

        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter removeAllPendingNotificationRequests]"]
        #[method(cancelAllLocalNotifications)]
        pub unsafe fn cancelAllLocalNotifications(&self);

        #[cfg(feature = "UILocalNotification")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getPendingNotificationRequestsWithCompletionHandler:]"]
        #[method_id(@__retain_semantics Other scheduledLocalNotifications)]
        pub unsafe fn scheduledLocalNotifications(
            &self,
        ) -> Option<Retained<NSArray<UILocalNotification>>>;

        #[cfg(feature = "UILocalNotification")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getPendingNotificationRequestsWithCompletionHandler:]"]
        #[method(setScheduledLocalNotifications:)]
        pub unsafe fn setScheduledLocalNotifications(
            &self,
            scheduled_local_notifications: Option<&NSArray<UILocalNotification>>,
        );
    }
);

extern_methods!(
    /// UIUserNotificationSettings
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[cfg(feature = "UIUserNotificationSettings")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:] and -[UNUserNotificationCenter setNotificationCategories:]"]
        #[method(registerUserNotificationSettings:)]
        pub unsafe fn registerUserNotificationSettings(
            &self,
            notification_settings: &UIUserNotificationSettings,
        );

        #[cfg(feature = "UIUserNotificationSettings")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getNotificationSettingsWithCompletionHandler:] and -[UNUserNotificationCenter getNotificationCategoriesWithCompletionHandler:]"]
        #[method_id(@__retain_semantics Other currentUserNotificationSettings)]
        pub unsafe fn currentUserNotificationSettings(
            &self,
        ) -> Option<Retained<UIUserNotificationSettings>>;
    }
);

extern_methods!(
    /// UIRemoteControlEvents
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method(beginReceivingRemoteControlEvents)]
        pub unsafe fn beginReceivingRemoteControlEvents(&self);

        #[method(endReceivingRemoteControlEvents)]
        pub unsafe fn endReceivingRemoteControlEvents(&self);
    }
);

extern_methods!(
    /// UINewsstand
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[cfg(feature = "UIImage")]
        #[deprecated = "Newsstand apps now behave like normal apps on SpringBoard"]
        #[method(setNewsstandIconImage:)]
        pub unsafe fn setNewsstandIconImage(&self, image: Option<&UIImage>);
    }
);

extern_methods!(
    /// UIShortcutItems
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[cfg(feature = "UIApplicationShortcutItem")]
        #[method_id(@__retain_semantics Other shortcutItems)]
        pub unsafe fn shortcutItems(&self) -> Option<Retained<NSArray<UIApplicationShortcutItem>>>;

        #[cfg(feature = "UIApplicationShortcutItem")]
        #[method(setShortcutItems:)]
        pub unsafe fn setShortcutItems(
            &self,
            shortcut_items: Option<&NSArray<UIApplicationShortcutItem>>,
        );
    }
);

extern_methods!(
    /// UIAlternateApplicationIcons
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method(supportsAlternateIcons)]
        pub unsafe fn supportsAlternateIcons(&self) -> bool;

        #[cfg(feature = "block2")]
        #[method(setAlternateIconName:completionHandler:)]
        pub unsafe fn setAlternateIconName_completionHandler(
            &self,
            alternate_icon_name: Option<&NSString>,
            completion_handler: Option<&block2::Block<dyn Fn(*mut NSError)>>,
        );

        #[method_id(@__retain_semantics Other alternateIconName)]
        pub unsafe fn alternateIconName(&self) -> Option<Retained<NSString>>;
    }
);

extern_methods!(
    /// UIStateRestoration
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[method(extendStateRestoration)]
        pub unsafe fn extendStateRestoration(&self);

        #[method(completeStateRestoration)]
        pub unsafe fn completeStateRestoration(&self);

        #[method(ignoreSnapshotOnNextApplicationLaunch)]
        pub unsafe fn ignoreSnapshotOnNextApplicationLaunch(&self);

        #[cfg(feature = "UIStateRestoration")]
        #[method(registerObjectForStateRestoration:restorationIdentifier:)]
        pub unsafe fn registerObjectForStateRestoration_restorationIdentifier(
            object: &ProtocolObject<dyn UIStateRestoring>,
            restoration_identifier: &NSString,
        );
    }
);

// NS_TYPED_ENUM
pub type UIApplicationLaunchOptionsKey = NSString;

// NS_TYPED_ENUM
pub type UIApplicationOpenURLOptionsKey = NSString;

// NS_TYPED_ENUM
pub type UIApplicationExtensionPointIdentifier = NSString;

extern_protocol!(
    pub unsafe trait UIApplicationDelegate: NSObjectProtocol + IsMainThreadOnly {
        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationDidFinishLaunching:)]
        unsafe fn applicationDidFinishLaunching(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:willFinishLaunchingWithOptions:)]
        unsafe fn application_willFinishLaunchingWithOptions(
            &self,
            application: &UIApplication,
            launch_options: Option<&NSDictionary<UIApplicationLaunchOptionsKey, AnyObject>>,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didFinishLaunchingWithOptions:)]
        unsafe fn application_didFinishLaunchingWithOptions(
            &self,
            application: &UIApplication,
            launch_options: Option<&NSDictionary<UIApplicationLaunchOptionsKey, AnyObject>>,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationDidBecomeActive:)]
        unsafe fn applicationDidBecomeActive(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationWillResignActive:)]
        unsafe fn applicationWillResignActive(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[deprecated]
        #[optional]
        #[method(application:handleOpenURL:)]
        unsafe fn application_handleOpenURL(
            &self,
            application: &UIApplication,
            url: &NSURL,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[deprecated]
        #[optional]
        #[method(application:openURL:sourceApplication:annotation:)]
        unsafe fn application_openURL_sourceApplication_annotation(
            &self,
            application: &UIApplication,
            url: &NSURL,
            source_application: Option<&NSString>,
            annotation: &AnyObject,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:openURL:options:)]
        unsafe fn application_openURL_options(
            &self,
            app: &UIApplication,
            url: &NSURL,
            options: &NSDictionary<UIApplicationOpenURLOptionsKey, AnyObject>,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationDidReceiveMemoryWarning:)]
        unsafe fn applicationDidReceiveMemoryWarning(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationWillTerminate:)]
        unsafe fn applicationWillTerminate(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationSignificantTimeChange:)]
        unsafe fn applicationSignificantTimeChange(&self, application: &UIApplication);

        #[cfg(all(feature = "UIOrientation", feature = "UIResponder"))]
        #[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
        #[optional]
        #[method(application:willChangeStatusBarOrientation:duration:)]
        unsafe fn application_willChangeStatusBarOrientation_duration(
            &self,
            application: &UIApplication,
            new_status_bar_orientation: UIInterfaceOrientation,
            duration: NSTimeInterval,
        );

        #[cfg(all(feature = "UIOrientation", feature = "UIResponder"))]
        #[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
        #[optional]
        #[method(application:didChangeStatusBarOrientation:)]
        unsafe fn application_didChangeStatusBarOrientation(
            &self,
            application: &UIApplication,
            old_status_bar_orientation: UIInterfaceOrientation,
        );

        #[cfg(feature = "UIResponder")]
        #[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
        #[optional]
        #[method(application:willChangeStatusBarFrame:)]
        unsafe fn application_willChangeStatusBarFrame(
            &self,
            application: &UIApplication,
            new_status_bar_frame: CGRect,
        );

        #[cfg(feature = "UIResponder")]
        #[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
        #[optional]
        #[method(application:didChangeStatusBarFrame:)]
        unsafe fn application_didChangeStatusBarFrame(
            &self,
            application: &UIApplication,
            old_status_bar_frame: CGRect,
        );

        #[cfg(all(feature = "UIResponder", feature = "UIUserNotificationSettings"))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:]"]
        #[optional]
        #[method(application:didRegisterUserNotificationSettings:)]
        unsafe fn application_didRegisterUserNotificationSettings(
            &self,
            application: &UIApplication,
            notification_settings: &UIUserNotificationSettings,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didRegisterForRemoteNotificationsWithDeviceToken:)]
        unsafe fn application_didRegisterForRemoteNotificationsWithDeviceToken(
            &self,
            application: &UIApplication,
            device_token: &NSData,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didFailToRegisterForRemoteNotificationsWithError:)]
        unsafe fn application_didFailToRegisterForRemoteNotificationsWithError(
            &self,
            application: &UIApplication,
            error: &NSError,
        );

        #[cfg(feature = "UIResponder")]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate willPresentNotification:withCompletionHandler:] or -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:] for user visible notifications and -[UIApplicationDelegate application:didReceiveRemoteNotification:fetchCompletionHandler:] for silent remote notifications"]
        #[optional]
        #[method(application:didReceiveRemoteNotification:)]
        unsafe fn application_didReceiveRemoteNotification(
            &self,
            application: &UIApplication,
            user_info: &NSDictionary,
        );

        #[cfg(all(feature = "UILocalNotification", feature = "UIResponder"))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate willPresentNotification:withCompletionHandler:] or -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
        #[optional]
        #[method(application:didReceiveLocalNotification:)]
        unsafe fn application_didReceiveLocalNotification(
            &self,
            application: &UIApplication,
            notification: &UILocalNotification,
        );

        #[cfg(all(
            feature = "UILocalNotification",
            feature = "UIResponder",
            feature = "block2"
        ))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
        #[optional]
        #[method(application:handleActionWithIdentifier:forLocalNotification:completionHandler:)]
        unsafe fn application_handleActionWithIdentifier_forLocalNotification_completionHandler(
            &self,
            application: &UIApplication,
            identifier: Option<&NSString>,
            notification: &UILocalNotification,
            completion_handler: &block2::Block<dyn Fn()>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
        #[optional]
        #[method(application:handleActionWithIdentifier:forRemoteNotification:withResponseInfo:completionHandler:)]
        unsafe fn application_handleActionWithIdentifier_forRemoteNotification_withResponseInfo_completionHandler(
            &self,
            application: &UIApplication,
            identifier: Option<&NSString>,
            user_info: &NSDictionary,
            response_info: &NSDictionary,
            completion_handler: &block2::Block<dyn Fn()>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
        #[optional]
        #[method(application:handleActionWithIdentifier:forRemoteNotification:completionHandler:)]
        unsafe fn application_handleActionWithIdentifier_forRemoteNotification_completionHandler(
            &self,
            application: &UIApplication,
            identifier: Option<&NSString>,
            user_info: &NSDictionary,
            completion_handler: &block2::Block<dyn Fn()>,
        );

        #[cfg(all(
            feature = "UILocalNotification",
            feature = "UIResponder",
            feature = "block2"
        ))]
        #[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
        #[optional]
        #[method(application:handleActionWithIdentifier:forLocalNotification:withResponseInfo:completionHandler:)]
        unsafe fn application_handleActionWithIdentifier_forLocalNotification_withResponseInfo_completionHandler(
            &self,
            application: &UIApplication,
            identifier: Option<&NSString>,
            notification: &UILocalNotification,
            response_info: &NSDictionary,
            completion_handler: &block2::Block<dyn Fn()>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[optional]
        #[method(application:didReceiveRemoteNotification:fetchCompletionHandler:)]
        unsafe fn application_didReceiveRemoteNotification_fetchCompletionHandler(
            &self,
            application: &UIApplication,
            user_info: &NSDictionary,
            completion_handler: &block2::Block<dyn Fn(UIBackgroundFetchResult)>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[deprecated = "Use a BGAppRefreshTask in the BackgroundTasks framework instead"]
        #[optional]
        #[method(application:performFetchWithCompletionHandler:)]
        unsafe fn application_performFetchWithCompletionHandler(
            &self,
            application: &UIApplication,
            completion_handler: &block2::Block<dyn Fn(UIBackgroundFetchResult)>,
        );

        #[cfg(all(
            feature = "UIApplicationShortcutItem",
            feature = "UIResponder",
            feature = "block2"
        ))]
        #[optional]
        #[method(application:performActionForShortcutItem:completionHandler:)]
        unsafe fn application_performActionForShortcutItem_completionHandler(
            &self,
            application: &UIApplication,
            shortcut_item: &UIApplicationShortcutItem,
            completion_handler: &block2::Block<dyn Fn(Bool)>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[optional]
        #[method(application:handleEventsForBackgroundURLSession:completionHandler:)]
        unsafe fn application_handleEventsForBackgroundURLSession_completionHandler(
            &self,
            application: &UIApplication,
            identifier: &NSString,
            completion_handler: &block2::Block<dyn Fn()>,
        );

        #[cfg(all(feature = "UIResponder", feature = "block2"))]
        #[optional]
        #[method(application:handleWatchKitExtensionRequest:reply:)]
        unsafe fn application_handleWatchKitExtensionRequest_reply(
            &self,
            application: &UIApplication,
            user_info: Option<&NSDictionary>,
            reply: &block2::Block<dyn Fn(*mut NSDictionary)>,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationShouldRequestHealthAuthorization:)]
        unsafe fn applicationShouldRequestHealthAuthorization(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationDidEnterBackground:)]
        unsafe fn applicationDidEnterBackground(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationWillEnterForeground:)]
        unsafe fn applicationWillEnterForeground(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationProtectedDataWillBecomeUnavailable:)]
        unsafe fn applicationProtectedDataWillBecomeUnavailable(&self, application: &UIApplication);

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationProtectedDataDidBecomeAvailable:)]
        unsafe fn applicationProtectedDataDidBecomeAvailable(&self, application: &UIApplication);

        #[cfg(all(feature = "UIResponder", feature = "UIView", feature = "UIWindow"))]
        #[optional]
        #[method_id(@__retain_semantics Other window)]
        unsafe fn window(&self) -> Option<Retained<UIWindow>>;

        #[cfg(all(feature = "UIResponder", feature = "UIView", feature = "UIWindow"))]
        #[optional]
        #[method(setWindow:)]
        unsafe fn setWindow(&self, window: Option<&UIWindow>);

        #[cfg(all(
            feature = "UIOrientation",
            feature = "UIResponder",
            feature = "UIView",
            feature = "UIWindow"
        ))]
        #[optional]
        #[method(application:supportedInterfaceOrientationsForWindow:)]
        unsafe fn application_supportedInterfaceOrientationsForWindow(
            &self,
            application: &UIApplication,
            window: Option<&UIWindow>,
        ) -> UIInterfaceOrientationMask;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:shouldAllowExtensionPointIdentifier:)]
        unsafe fn application_shouldAllowExtensionPointIdentifier(
            &self,
            application: &UIApplication,
            extension_point_identifier: &UIApplicationExtensionPointIdentifier,
        ) -> bool;

        #[cfg(all(feature = "UIResponder", feature = "UIViewController"))]
        #[optional]
        #[method_id(@__retain_semantics Other application:viewControllerWithRestorationIdentifierPath:coder:)]
        unsafe fn application_viewControllerWithRestorationIdentifierPath_coder(
            &self,
            application: &UIApplication,
            identifier_components: &NSArray<NSString>,
            coder: &NSCoder,
        ) -> Option<Retained<UIViewController>>;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:shouldSaveSecureApplicationState:)]
        unsafe fn application_shouldSaveSecureApplicationState(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:shouldRestoreSecureApplicationState:)]
        unsafe fn application_shouldRestoreSecureApplicationState(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:willEncodeRestorableStateWithCoder:)]
        unsafe fn application_willEncodeRestorableStateWithCoder(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didDecodeRestorableStateWithCoder:)]
        unsafe fn application_didDecodeRestorableStateWithCoder(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        );

        #[cfg(feature = "UIResponder")]
        #[deprecated = "Use application:shouldSaveSecureApplicationState: instead"]
        #[optional]
        #[method(application:shouldSaveApplicationState:)]
        unsafe fn application_shouldSaveApplicationState(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[deprecated = "Use application:shouldRestoreSecureApplicationState: instead"]
        #[optional]
        #[method(application:shouldRestoreApplicationState:)]
        unsafe fn application_shouldRestoreApplicationState(
            &self,
            application: &UIApplication,
            coder: &NSCoder,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:willContinueUserActivityWithType:)]
        unsafe fn application_willContinueUserActivityWithType(
            &self,
            application: &UIApplication,
            user_activity_type: &NSString,
        ) -> bool;

        #[cfg(all(
            feature = "UIResponder",
            feature = "UIUserActivity",
            feature = "block2"
        ))]
        #[optional]
        #[method(application:continueUserActivity:restorationHandler:)]
        unsafe fn application_continueUserActivity_restorationHandler(
            &self,
            application: &UIApplication,
            user_activity: &NSUserActivity,
            restoration_handler: &block2::Block<
                dyn Fn(*mut NSArray<ProtocolObject<dyn UIUserActivityRestoring>>),
            >,
        ) -> bool;

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didFailToContinueUserActivityWithType:error:)]
        unsafe fn application_didFailToContinueUserActivityWithType_error(
            &self,
            application: &UIApplication,
            user_activity_type: &NSString,
            error: &NSError,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(application:didUpdateUserActivity:)]
        unsafe fn application_didUpdateUserActivity(
            &self,
            application: &UIApplication,
            user_activity: &NSUserActivity,
        );

        #[cfg(all(feature = "UIResponder", feature = "objc2-cloud-kit"))]
        #[optional]
        #[method(application:userDidAcceptCloudKitShareWithMetadata:)]
        unsafe fn application_userDidAcceptCloudKitShareWithMetadata(
            &self,
            application: &UIApplication,
            cloud_kit_share_metadata: &CKShareMetadata,
        );

        #[cfg(all(
            feature = "UIResponder",
            feature = "UISceneOptions",
            feature = "UISceneSession"
        ))]
        #[optional]
        #[method_id(@__retain_semantics Other application:configurationForConnectingSceneSession:options:)]
        unsafe fn application_configurationForConnectingSceneSession_options(
            &self,
            application: &UIApplication,
            connecting_scene_session: &UISceneSession,
            options: &UISceneConnectionOptions,
        ) -> Retained<UISceneConfiguration>;

        #[cfg(all(feature = "UIResponder", feature = "UISceneSession"))]
        #[optional]
        #[method(application:didDiscardSceneSessions:)]
        unsafe fn application_didDiscardSceneSessions(
            &self,
            application: &UIApplication,
            scene_sessions: &NSSet<UISceneSession>,
        );

        #[cfg(feature = "UIResponder")]
        #[optional]
        #[method(applicationShouldAutomaticallyLocalizeKeyCommands:)]
        unsafe fn applicationShouldAutomaticallyLocalizeKeyCommands(
            &self,
            application: &UIApplication,
        ) -> bool;
    }

    unsafe impl ProtocolType for dyn UIApplicationDelegate {}
);

extern_methods!(
    /// UIApplicationDeprecated
    #[cfg(feature = "UIResponder")]
    unsafe impl UIApplication {
        #[deprecated]
        #[method(isProximitySensingEnabled)]
        pub unsafe fn isProximitySensingEnabled(&self) -> bool;

        #[deprecated]
        #[method(setProximitySensingEnabled:)]
        pub unsafe fn setProximitySensingEnabled(&self, proximity_sensing_enabled: bool);

        #[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
        #[method(setStatusBarHidden:animated:)]
        pub unsafe fn setStatusBarHidden_animated(&self, hidden: bool, animated: bool);

        #[cfg(feature = "UIOrientation")]
        #[deprecated = "Explicit setting of the status bar orientation is more limited in iOS 6.0 and later"]
        #[method(setStatusBarOrientation:)]
        pub unsafe fn setStatusBarOrientation(
            &self,
            status_bar_orientation: UIInterfaceOrientation,
        );

        #[cfg(feature = "UIOrientation")]
        #[deprecated = "Explicit setting of the status bar orientation is more limited in iOS 6.0 and later"]
        #[method(setStatusBarOrientation:animated:)]
        pub unsafe fn setStatusBarOrientation_animated(
            &self,
            interface_orientation: UIInterfaceOrientation,
            animated: bool,
        );

        #[deprecated = "Use -[UIViewController preferredStatusBarStyle]"]
        #[method(setStatusBarStyle:)]
        pub unsafe fn setStatusBarStyle(&self, status_bar_style: UIStatusBarStyle);

        #[deprecated = "Use -[UIViewController preferredStatusBarStyle]"]
        #[method(setStatusBarStyle:animated:)]
        pub unsafe fn setStatusBarStyle_animated(
            &self,
            status_bar_style: UIStatusBarStyle,
            animated: bool,
        );

        #[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
        #[method(setStatusBarHidden:)]
        pub unsafe fn setStatusBarHidden(&self, status_bar_hidden: bool);

        #[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
        #[method(setStatusBarHidden:withAnimation:)]
        pub unsafe fn setStatusBarHidden_withAnimation(
            &self,
            hidden: bool,
            animation: UIStatusBarAnimation,
        );

        #[cfg(feature = "block2")]
        #[deprecated = "Please use PushKit for VoIP applications instead of calling this method"]
        #[method(setKeepAliveTimeout:handler:)]
        pub unsafe fn setKeepAliveTimeout_handler(
            &self,
            timeout: NSTimeInterval,
            keep_alive_handler: Option<&block2::Block<dyn Fn()>>,
        ) -> bool;

        #[deprecated = "Please use PushKit for VoIP applications instead of calling this method"]
        #[method(clearKeepAliveTimeout)]
        pub unsafe fn clearKeepAliveTimeout(&self);
    }
);

extern "C" {
    pub fn UIApplicationMain(
        argc: c_int,
        argv: NonNull<*mut c_char>,
        principal_class_name: Option<&NSString>,
        delegate_class_name: Option<&NSString>,
    ) -> c_int;
}

extern "C" {
    pub static UITrackingRunLoopMode: &'static NSRunLoopMode;
}

extern "C" {
    pub static UIApplicationDidEnterBackgroundNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationWillEnterForegroundNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationDidFinishLaunchingNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationDidBecomeActiveNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationWillResignActiveNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationDidReceiveMemoryWarningNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationWillTerminateNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationSignificantTimeChangeNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationWillChangeStatusBarOrientationNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationDidChangeStatusBarOrientationNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationStatusBarOrientationUserInfoKey: &'static NSString;
}

extern "C" {
    pub static UIApplicationWillChangeStatusBarFrameNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationDidChangeStatusBarFrameNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationStatusBarFrameUserInfoKey: &'static NSString;
}

extern "C" {
    pub static UIApplicationBackgroundRefreshStatusDidChangeNotification:
        &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationProtectedDataWillBecomeUnavailable: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationProtectedDataDidBecomeAvailable: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationLaunchOptionsURLKey: &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsSourceApplicationKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsRemoteNotificationKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsLocalNotificationKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsAnnotationKey: &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsLocationKey: &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsNewsstandDownloadsKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsBluetoothCentralsKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsBluetoothPeripheralsKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsShortcutItemKey: &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsEventAttributionKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsUserActivityDictionaryKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsUserActivityTypeKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationLaunchOptionsCloudKitShareMetadataKey:
        &'static UIApplicationLaunchOptionsKey;
}

extern "C" {
    pub static UIApplicationOpenSettingsURLString: &'static NSString;
}

extern "C" {
    pub static UIApplicationOpenNotificationSettingsURLString: &'static NSString;
}

extern "C" {
    pub static UIApplicationOpenURLOptionsSourceApplicationKey:
        &'static UIApplicationOpenURLOptionsKey;
}

extern "C" {
    pub static UIApplicationOpenURLOptionsAnnotationKey: &'static UIApplicationOpenURLOptionsKey;
}

extern "C" {
    pub static UIApplicationOpenURLOptionsOpenInPlaceKey: &'static UIApplicationOpenURLOptionsKey;
}

extern "C" {
    pub static UIApplicationOpenURLOptionsEventAttributionKey:
        &'static UIApplicationOpenURLOptionsKey;
}

extern "C" {
    pub static UIApplicationUserDidTakeScreenshotNotification: &'static NSNotificationName;
}

extern "C" {
    pub static UIApplicationKeyboardExtensionPointIdentifier:
        &'static UIApplicationExtensionPointIdentifier;
}

extern "C" {
    pub static UIApplicationOpenURLOptionUniversalLinksOnly:
        &'static UIApplicationOpenExternalURLOptionsKey;
}

extern "C" {
    pub static UIApplicationOpenExternalURLOptionsEventAttributionKey:
        &'static UIApplicationOpenExternalURLOptionsKey;
}
