//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use objc2::__framework_prelude::*;
use objc2_foundation::*;
#[cfg(feature = "objc2-quartz-core")]
#[cfg(not(target_os = "watchos"))]
use objc2_quartz_core::*;

use crate::*;

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewAnimationCurve(pub NSInteger);
impl UIViewAnimationCurve {
    #[doc(alias = "UIViewAnimationCurveEaseInOut")]
    pub const EaseInOut: Self = Self(0);
    #[doc(alias = "UIViewAnimationCurveEaseIn")]
    pub const EaseIn: Self = Self(1);
    #[doc(alias = "UIViewAnimationCurveEaseOut")]
    pub const EaseOut: Self = Self(2);
    #[doc(alias = "UIViewAnimationCurveLinear")]
    pub const Linear: Self = Self(3);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewContentMode(pub NSInteger);
impl UIViewContentMode {
    #[doc(alias = "UIViewContentModeScaleToFill")]
    pub const ScaleToFill: Self = Self(0);
    #[doc(alias = "UIViewContentModeScaleAspectFit")]
    pub const ScaleAspectFit: Self = Self(1);
    #[doc(alias = "UIViewContentModeScaleAspectFill")]
    pub const ScaleAspectFill: Self = Self(2);
    #[doc(alias = "UIViewContentModeRedraw")]
    pub const Redraw: Self = Self(3);
    #[doc(alias = "UIViewContentModeCenter")]
    pub const Center: Self = Self(4);
    #[doc(alias = "UIViewContentModeTop")]
    pub const Top: Self = Self(5);
    #[doc(alias = "UIViewContentModeBottom")]
    pub const Bottom: Self = Self(6);
    #[doc(alias = "UIViewContentModeLeft")]
    pub const Left: Self = Self(7);
    #[doc(alias = "UIViewContentModeRight")]
    pub const Right: Self = Self(8);
    #[doc(alias = "UIViewContentModeTopLeft")]
    pub const TopLeft: Self = Self(9);
    #[doc(alias = "UIViewContentModeTopRight")]
    pub const TopRight: Self = Self(10);
    #[doc(alias = "UIViewContentModeBottomLeft")]
    pub const BottomLeft: Self = Self(11);
    #[doc(alias = "UIViewContentModeBottomRight")]
    pub const BottomRight: Self = Self(12);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewAnimationTransition(pub NSInteger);
impl UIViewAnimationTransition {
    #[doc(alias = "UIViewAnimationTransitionNone")]
    pub const None: Self = Self(0);
    #[doc(alias = "UIViewAnimationTransitionFlipFromLeft")]
    pub const FlipFromLeft: Self = Self(1);
    #[doc(alias = "UIViewAnimationTransitionFlipFromRight")]
    pub const FlipFromRight: Self = Self(2);
    #[doc(alias = "UIViewAnimationTransitionCurlUp")]
    pub const CurlUp: Self = Self(3);
    #[doc(alias = "UIViewAnimationTransitionCurlDown")]
    pub const CurlDown: Self = Self(4);
}

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

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

// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewAutoresizing(pub NSUInteger);
bitflags::bitflags! {
    impl UIViewAutoresizing: NSUInteger {
        #[doc(alias = "UIViewAutoresizingNone")]
        const None = 0;
        #[doc(alias = "UIViewAutoresizingFlexibleLeftMargin")]
        const FlexibleLeftMargin = 1<<0;
        #[doc(alias = "UIViewAutoresizingFlexibleWidth")]
        const FlexibleWidth = 1<<1;
        #[doc(alias = "UIViewAutoresizingFlexibleRightMargin")]
        const FlexibleRightMargin = 1<<2;
        #[doc(alias = "UIViewAutoresizingFlexibleTopMargin")]
        const FlexibleTopMargin = 1<<3;
        #[doc(alias = "UIViewAutoresizingFlexibleHeight")]
        const FlexibleHeight = 1<<4;
        #[doc(alias = "UIViewAutoresizingFlexibleBottomMargin")]
        const FlexibleBottomMargin = 1<<5;
    }
}

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

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

// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewAnimationOptions(pub NSUInteger);
bitflags::bitflags! {
    impl UIViewAnimationOptions: NSUInteger {
        const UIViewAnimationOptionLayoutSubviews = 1<<0;
        const UIViewAnimationOptionAllowUserInteraction = 1<<1;
        const UIViewAnimationOptionBeginFromCurrentState = 1<<2;
        const UIViewAnimationOptionRepeat = 1<<3;
        const UIViewAnimationOptionAutoreverse = 1<<4;
        const UIViewAnimationOptionOverrideInheritedDuration = 1<<5;
        const UIViewAnimationOptionOverrideInheritedCurve = 1<<6;
        const UIViewAnimationOptionAllowAnimatedContent = 1<<7;
        const UIViewAnimationOptionShowHideTransitionViews = 1<<8;
        const UIViewAnimationOptionOverrideInheritedOptions = 1<<9;
        const UIViewAnimationOptionCurveEaseInOut = 0<<16;
        const UIViewAnimationOptionCurveEaseIn = 1<<16;
        const UIViewAnimationOptionCurveEaseOut = 2<<16;
        const UIViewAnimationOptionCurveLinear = 3<<16;
        const UIViewAnimationOptionTransitionNone = 0<<20;
        const UIViewAnimationOptionTransitionFlipFromLeft = 1<<20;
        const UIViewAnimationOptionTransitionFlipFromRight = 2<<20;
        const UIViewAnimationOptionTransitionCurlUp = 3<<20;
        const UIViewAnimationOptionTransitionCurlDown = 4<<20;
        const UIViewAnimationOptionTransitionCrossDissolve = 5<<20;
        const UIViewAnimationOptionTransitionFlipFromTop = 6<<20;
        const UIViewAnimationOptionTransitionFlipFromBottom = 7<<20;
        const UIViewAnimationOptionPreferredFramesPerSecondDefault = 0<<24;
        const UIViewAnimationOptionPreferredFramesPerSecond60 = 3<<24;
        const UIViewAnimationOptionPreferredFramesPerSecond30 = 7<<24;
    }
}

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

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

// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewKeyframeAnimationOptions(pub NSUInteger);
bitflags::bitflags! {
    impl UIViewKeyframeAnimationOptions: NSUInteger {
        const UIViewKeyframeAnimationOptionLayoutSubviews = UIViewAnimationOptions::UIViewAnimationOptionLayoutSubviews.0;
        const UIViewKeyframeAnimationOptionAllowUserInteraction = UIViewAnimationOptions::UIViewAnimationOptionAllowUserInteraction.0;
        const UIViewKeyframeAnimationOptionBeginFromCurrentState = UIViewAnimationOptions::UIViewAnimationOptionBeginFromCurrentState.0;
        const UIViewKeyframeAnimationOptionRepeat = UIViewAnimationOptions::UIViewAnimationOptionRepeat.0;
        const UIViewKeyframeAnimationOptionAutoreverse = UIViewAnimationOptions::UIViewAnimationOptionAutoreverse.0;
        const UIViewKeyframeAnimationOptionOverrideInheritedDuration = UIViewAnimationOptions::UIViewAnimationOptionOverrideInheritedDuration.0;
        const UIViewKeyframeAnimationOptionOverrideInheritedOptions = UIViewAnimationOptions::UIViewAnimationOptionOverrideInheritedOptions.0;
        const UIViewKeyframeAnimationOptionCalculationModeLinear = 0<<10;
        const UIViewKeyframeAnimationOptionCalculationModeDiscrete = 1<<10;
        const UIViewKeyframeAnimationOptionCalculationModePaced = 2<<10;
        const UIViewKeyframeAnimationOptionCalculationModeCubic = 3<<10;
        const UIViewKeyframeAnimationOptionCalculationModeCubicPaced = 4<<10;
    }
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UISystemAnimation(pub NSUInteger);
impl UISystemAnimation {
    #[doc(alias = "UISystemAnimationDelete")]
    pub const Delete: Self = Self(0);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIViewTintAdjustmentMode(pub NSInteger);
impl UIViewTintAdjustmentMode {
    #[doc(alias = "UIViewTintAdjustmentModeAutomatic")]
    pub const Automatic: Self = Self(0);
    #[doc(alias = "UIViewTintAdjustmentModeNormal")]
    pub const Normal: Self = Self(1);
    #[doc(alias = "UIViewTintAdjustmentModeDimmed")]
    pub const Dimmed: Self = Self(2);
}

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

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

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UISemanticContentAttribute(pub NSInteger);
impl UISemanticContentAttribute {
    #[doc(alias = "UISemanticContentAttributeUnspecified")]
    pub const Unspecified: Self = Self(0);
    #[doc(alias = "UISemanticContentAttributePlayback")]
    pub const Playback: Self = Self(1);
    #[doc(alias = "UISemanticContentAttributeSpatial")]
    pub const Spatial: Self = Self(2);
    #[doc(alias = "UISemanticContentAttributeForceLeftToRight")]
    pub const ForceLeftToRight: Self = Self(3);
    #[doc(alias = "UISemanticContentAttributeForceRightToLeft")]
    pub const ForceRightToLeft: Self = Self(4);
}

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

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

extern_protocol!(
    pub unsafe trait UICoordinateSpace: NSObjectProtocol + IsMainThreadOnly {
        #[method(convertPoint:toCoordinateSpace:)]
        fn convertPoint_toCoordinateSpace(
            &self,
            point: CGPoint,
            coordinate_space: &ProtocolObject<dyn UICoordinateSpace>,
        ) -> CGPoint;

        #[method(convertPoint:fromCoordinateSpace:)]
        fn convertPoint_fromCoordinateSpace(
            &self,
            point: CGPoint,
            coordinate_space: &ProtocolObject<dyn UICoordinateSpace>,
        ) -> CGPoint;

        #[method(convertRect:toCoordinateSpace:)]
        fn convertRect_toCoordinateSpace(
            &self,
            rect: CGRect,
            coordinate_space: &ProtocolObject<dyn UICoordinateSpace>,
        ) -> CGRect;

        #[method(convertRect:fromCoordinateSpace:)]
        fn convertRect_fromCoordinateSpace(
            &self,
            rect: CGRect,
            coordinate_space: &ProtocolObject<dyn UICoordinateSpace>,
        ) -> CGRect;

        #[method(bounds)]
        fn bounds(&self) -> CGRect;
    }

    unsafe impl ProtocolType for dyn UICoordinateSpace {}
);

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

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

#[cfg(all(feature = "UIResponder", feature = "objc2-quartz-core"))]
#[cfg(not(target_os = "watchos"))]
unsafe impl CALayerDelegate for UIView {}

#[cfg(feature = "UIResponder")]
unsafe impl NSCoding for UIView {}

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

#[cfg(all(feature = "UIAppearance", feature = "UIResponder"))]
unsafe impl UIAppearance for UIView {}

#[cfg(all(feature = "UIAppearance", feature = "UIResponder"))]
unsafe impl UIAppearanceContainer for UIView {}

#[cfg(feature = "UIResponder")]
unsafe impl UICoordinateSpace for UIView {}

#[cfg(all(feature = "UIDynamicBehavior", feature = "UIResponder"))]
unsafe impl UIDynamicItem for UIView {}

#[cfg(all(feature = "UIFocus", feature = "UIResponder"))]
unsafe impl UIFocusEnvironment for UIView {}

#[cfg(all(feature = "UIFocus", feature = "UIResponder"))]
unsafe impl UIFocusItem for UIView {}

#[cfg(all(feature = "UIFocus", feature = "UIResponder"))]
unsafe impl UIFocusItemContainer for UIView {}

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

#[cfg(all(feature = "UIResponder", feature = "UITraitCollection"))]
unsafe impl UITraitEnvironment for UIView {}

extern_methods!(
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(layerClass)]
        pub fn layerClass(mtm: MainThreadMarker) -> &'static AnyClass;

        #[method_id(@__retain_semantics Init initWithFrame:)]
        pub fn initWithFrame(this: Allocated<Self>, frame: CGRect) -> Retained<Self>;

        #[method_id(@__retain_semantics Init initWithCoder:)]
        pub unsafe fn initWithCoder(
            this: Allocated<Self>,
            coder: &NSCoder,
        ) -> Option<Retained<Self>>;

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

        #[method(setUserInteractionEnabled:)]
        pub unsafe fn setUserInteractionEnabled(&self, user_interaction_enabled: bool);

        #[method(tag)]
        pub unsafe fn tag(&self) -> NSInteger;

        #[method(setTag:)]
        pub unsafe fn setTag(&self, tag: NSInteger);

        #[cfg(feature = "objc2-quartz-core")]
        #[cfg(not(target_os = "watchos"))]
        #[method_id(@__retain_semantics Other layer)]
        pub fn layer(&self) -> Retained<CALayer>;

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

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

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

        #[method(setFocusGroupIdentifier:)]
        pub unsafe fn setFocusGroupIdentifier(&self, focus_group_identifier: Option<&NSString>);

        #[cfg(feature = "UIFocus")]
        #[method(focusGroupPriority)]
        pub unsafe fn focusGroupPriority(&self) -> UIFocusGroupPriority;

        #[cfg(feature = "UIFocus")]
        #[method(setFocusGroupPriority:)]
        pub unsafe fn setFocusGroupPriority(&self, focus_group_priority: UIFocusGroupPriority);

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

        #[cfg(feature = "UIFocusEffect")]
        #[method(setFocusEffect:)]
        pub unsafe fn setFocusEffect(&self, focus_effect: Option<&UIFocusEffect>);

        #[method(semanticContentAttribute)]
        pub unsafe fn semanticContentAttribute(&self) -> UISemanticContentAttribute;

        #[method(setSemanticContentAttribute:)]
        pub unsafe fn setSemanticContentAttribute(
            &self,
            semantic_content_attribute: UISemanticContentAttribute,
        );

        #[cfg(feature = "UIInterface")]
        #[method(userInterfaceLayoutDirectionForSemanticContentAttribute:)]
        pub unsafe fn userInterfaceLayoutDirectionForSemanticContentAttribute(
            attribute: UISemanticContentAttribute,
            mtm: MainThreadMarker,
        ) -> UIUserInterfaceLayoutDirection;

        #[cfg(feature = "UIInterface")]
        #[method(userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection:)]
        pub unsafe fn userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection(
            semantic_content_attribute: UISemanticContentAttribute,
            layout_direction: UIUserInterfaceLayoutDirection,
            mtm: MainThreadMarker,
        ) -> UIUserInterfaceLayoutDirection;

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

extern_methods!(
    /// Methods declared on superclass `NSObject`
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[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!(
    /// UIViewGeometry
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(frame)]
        pub fn frame(&self) -> CGRect;

        #[method(setFrame:)]
        pub fn setFrame(&self, frame: CGRect);

        #[method(bounds)]
        pub fn bounds(&self) -> CGRect;

        #[method(setBounds:)]
        pub fn setBounds(&self, bounds: CGRect);

        #[method(center)]
        pub unsafe fn center(&self) -> CGPoint;

        #[method(setCenter:)]
        pub unsafe fn setCenter(&self, center: CGPoint);

        #[cfg(feature = "objc2-quartz-core")]
        #[cfg(not(target_os = "watchos"))]
        #[method(transform3D)]
        pub unsafe fn transform3D(&self) -> CATransform3D;

        #[cfg(feature = "objc2-quartz-core")]
        #[cfg(not(target_os = "watchos"))]
        #[method(setTransform3D:)]
        pub unsafe fn setTransform3D(&self, transform3_d: CATransform3D);

        #[method(contentScaleFactor)]
        pub fn contentScaleFactor(&self) -> CGFloat;

        #[method(setContentScaleFactor:)]
        pub fn setContentScaleFactor(&self, content_scale_factor: CGFloat);

        #[method(anchorPoint)]
        pub unsafe fn anchorPoint(&self) -> CGPoint;

        #[method(setAnchorPoint:)]
        pub unsafe fn setAnchorPoint(&self, anchor_point: CGPoint);

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

        #[method(setMultipleTouchEnabled:)]
        pub fn setMultipleTouchEnabled(&self, multiple_touch_enabled: bool);

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

        #[method(setExclusiveTouch:)]
        pub unsafe fn setExclusiveTouch(&self, exclusive_touch: bool);

        #[cfg(feature = "UIEvent")]
        #[method_id(@__retain_semantics Other hitTest:withEvent:)]
        pub unsafe fn hitTest_withEvent(
            &self,
            point: CGPoint,
            event: Option<&UIEvent>,
        ) -> Option<Retained<UIView>>;

        #[cfg(feature = "UIEvent")]
        #[method(pointInside:withEvent:)]
        pub unsafe fn pointInside_withEvent(&self, point: CGPoint, event: Option<&UIEvent>)
            -> bool;

        #[method(convertPoint:toView:)]
        pub unsafe fn convertPoint_toView(&self, point: CGPoint, view: Option<&UIView>) -> CGPoint;

        #[method(convertPoint:fromView:)]
        pub unsafe fn convertPoint_fromView(
            &self,
            point: CGPoint,
            view: Option<&UIView>,
        ) -> CGPoint;

        #[method(convertRect:toView:)]
        pub unsafe fn convertRect_toView(&self, rect: CGRect, view: Option<&UIView>) -> CGRect;

        #[method(convertRect:fromView:)]
        pub unsafe fn convertRect_fromView(&self, rect: CGRect, view: Option<&UIView>) -> CGRect;

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

        #[method(setAutoresizesSubviews:)]
        pub unsafe fn setAutoresizesSubviews(&self, autoresizes_subviews: bool);

        #[method(autoresizingMask)]
        pub unsafe fn autoresizingMask(&self) -> UIViewAutoresizing;

        #[method(setAutoresizingMask:)]
        pub unsafe fn setAutoresizingMask(&self, autoresizing_mask: UIViewAutoresizing);

        #[method(sizeThatFits:)]
        pub unsafe fn sizeThatFits(&self, size: CGSize) -> CGSize;

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

extern_methods!(
    /// UIViewHierarchy
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method_id(@__retain_semantics Other superview)]
        pub fn superview(&self) -> Option<Retained<UIView>>;

        #[method_id(@__retain_semantics Other subviews)]
        pub fn subviews(&self) -> Retained<NSArray<UIView>>;

        #[cfg(feature = "UIWindow")]
        #[method_id(@__retain_semantics Other window)]
        pub fn window(&self) -> Option<Retained<UIWindow>>;

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

        #[method(insertSubview:atIndex:)]
        pub unsafe fn insertSubview_atIndex(&self, view: &UIView, index: NSInteger);

        #[method(exchangeSubviewAtIndex:withSubviewAtIndex:)]
        pub unsafe fn exchangeSubviewAtIndex_withSubviewAtIndex(
            &self,
            index1: NSInteger,
            index2: NSInteger,
        );

        #[method(addSubview:)]
        pub unsafe fn addSubview(&self, view: &UIView);

        #[method(insertSubview:belowSubview:)]
        pub unsafe fn insertSubview_belowSubview(&self, view: &UIView, sibling_subview: &UIView);

        #[method(insertSubview:aboveSubview:)]
        pub unsafe fn insertSubview_aboveSubview(&self, view: &UIView, sibling_subview: &UIView);

        #[method(bringSubviewToFront:)]
        pub unsafe fn bringSubviewToFront(&self, view: &UIView);

        #[method(sendSubviewToBack:)]
        pub unsafe fn sendSubviewToBack(&self, view: &UIView);

        #[method(didAddSubview:)]
        pub unsafe fn didAddSubview(&self, subview: &UIView);

        #[method(willRemoveSubview:)]
        pub unsafe fn willRemoveSubview(&self, subview: &UIView);

        #[method(willMoveToSuperview:)]
        pub unsafe fn willMoveToSuperview(&self, new_superview: Option<&UIView>);

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

        #[cfg(feature = "UIWindow")]
        #[method(willMoveToWindow:)]
        pub unsafe fn willMoveToWindow(&self, new_window: Option<&UIWindow>);

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

        #[method(isDescendantOfView:)]
        pub unsafe fn isDescendantOfView(&self, view: &UIView) -> bool;

        #[method_id(@__retain_semantics Other viewWithTag:)]
        pub unsafe fn viewWithTag(&self, tag: NSInteger) -> Option<Retained<UIView>>;

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

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

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

        #[cfg(feature = "UIGeometry")]
        #[method(layoutMargins)]
        pub unsafe fn layoutMargins(&self) -> UIEdgeInsets;

        #[cfg(feature = "UIGeometry")]
        #[method(setLayoutMargins:)]
        pub unsafe fn setLayoutMargins(&self, layout_margins: UIEdgeInsets);

        #[cfg(feature = "UIGeometry")]
        #[method(directionalLayoutMargins)]
        pub unsafe fn directionalLayoutMargins(&self) -> NSDirectionalEdgeInsets;

        #[cfg(feature = "UIGeometry")]
        #[method(setDirectionalLayoutMargins:)]
        pub unsafe fn setDirectionalLayoutMargins(
            &self,
            directional_layout_margins: NSDirectionalEdgeInsets,
        );

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

        #[method(setPreservesSuperviewLayoutMargins:)]
        pub unsafe fn setPreservesSuperviewLayoutMargins(
            &self,
            preserves_superview_layout_margins: bool,
        );

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

        #[method(setInsetsLayoutMarginsFromSafeArea:)]
        pub unsafe fn setInsetsLayoutMarginsFromSafeArea(
            &self,
            insets_layout_margins_from_safe_area: bool,
        );

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

        #[cfg(feature = "UIGeometry")]
        #[method(safeAreaInsets)]
        pub fn safeAreaInsets(&self) -> UIEdgeInsets;

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

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

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

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

        #[cfg(all(
            feature = "UIKeyboardLayoutGuide",
            feature = "UILayoutGuide",
            feature = "UITrackingLayoutGuide"
        ))]
        #[method_id(@__retain_semantics Other keyboardLayoutGuide)]
        pub unsafe fn keyboardLayoutGuide(&self) -> Retained<UIKeyboardLayoutGuide>;
    }
);

extern_methods!(
    /// UIViewRendering
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(drawRect:)]
        pub unsafe fn drawRect(&self, rect: CGRect);

        #[method(setNeedsDisplay)]
        pub fn setNeedsDisplay(&self);

        #[method(setNeedsDisplayInRect:)]
        pub unsafe fn setNeedsDisplayInRect(&self, rect: CGRect);

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

        #[method(setClipsToBounds:)]
        pub unsafe fn setClipsToBounds(&self, clips_to_bounds: bool);

        #[cfg(feature = "UIColor")]
        #[method_id(@__retain_semantics Other backgroundColor)]
        pub fn backgroundColor(&self) -> Option<Retained<UIColor>>;

        #[cfg(feature = "UIColor")]
        #[method(setBackgroundColor:)]
        pub fn setBackgroundColor(&self, background_color: Option<&UIColor>);

        #[method(alpha)]
        pub unsafe fn alpha(&self) -> CGFloat;

        #[method(setAlpha:)]
        pub unsafe fn setAlpha(&self, alpha: CGFloat);

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

        #[method(setOpaque:)]
        pub unsafe fn setOpaque(&self, opaque: bool);

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

        #[method(setClearsContextBeforeDrawing:)]
        pub unsafe fn setClearsContextBeforeDrawing(&self, clears_context_before_drawing: bool);

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

        #[method(setHidden:)]
        pub fn setHidden(&self, hidden: bool);

        #[method(contentMode)]
        pub unsafe fn contentMode(&self) -> UIViewContentMode;

        #[method(setContentMode:)]
        pub unsafe fn setContentMode(&self, content_mode: UIViewContentMode);

        #[deprecated]
        #[method(contentStretch)]
        pub unsafe fn contentStretch(&self) -> CGRect;

        #[deprecated]
        #[method(setContentStretch:)]
        pub unsafe fn setContentStretch(&self, content_stretch: CGRect);

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

        #[method(setMaskView:)]
        pub unsafe fn setMaskView(&self, mask_view: Option<&UIView>);

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

        #[cfg(feature = "UIColor")]
        #[method(setTintColor:)]
        pub unsafe fn setTintColor(&self, tint_color: Option<&UIColor>);

        #[method(tintAdjustmentMode)]
        pub unsafe fn tintAdjustmentMode(&self) -> UIViewTintAdjustmentMode;

        #[method(setTintAdjustmentMode:)]
        pub unsafe fn setTintAdjustmentMode(&self, tint_adjustment_mode: UIViewTintAdjustmentMode);

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

extern_methods!(
    /// UIViewAnimation
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(setAnimationsEnabled:)]
        pub unsafe fn setAnimationsEnabled(enabled: bool, mtm: MainThreadMarker);

        #[method(areAnimationsEnabled)]
        pub unsafe fn areAnimationsEnabled(mtm: MainThreadMarker) -> bool;

        #[cfg(feature = "block2")]
        #[method(performWithoutAnimation:)]
        pub unsafe fn performWithoutAnimation(
            actions_without_animation: &block2::Block<dyn Fn() + '_>,
            mtm: MainThreadMarker,
        );

        #[method(inheritedAnimationDuration)]
        pub unsafe fn inheritedAnimationDuration(mtm: MainThreadMarker) -> NSTimeInterval;
    }
);

extern_methods!(
    /// UIViewAnimationWithBlocks
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "block2")]
        #[method(animateWithDuration:delay:options:animations:completion:)]
        pub unsafe fn animateWithDuration_delay_options_animations_completion(
            duration: NSTimeInterval,
            delay: NSTimeInterval,
            options: UIViewAnimationOptions,
            animations: &block2::Block<dyn Fn()>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(animateWithDuration:animations:completion:)]
        pub unsafe fn animateWithDuration_animations_completion(
            duration: NSTimeInterval,
            animations: &block2::Block<dyn Fn()>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(animateWithDuration:animations:)]
        pub unsafe fn animateWithDuration_animations(
            duration: NSTimeInterval,
            animations: &block2::Block<dyn Fn()>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(animateWithSpringDuration:bounce:initialSpringVelocity:delay:options:animations:completion:)]
        pub unsafe fn animateWithSpringDuration_bounce_initialSpringVelocity_delay_options_animations_completion(
            duration: NSTimeInterval,
            bounce: CGFloat,
            velocity: CGFloat,
            delay: NSTimeInterval,
            options: UIViewAnimationOptions,
            animations: &block2::Block<dyn Fn() + '_>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(animateWithDuration:delay:usingSpringWithDamping:initialSpringVelocity:options:animations:completion:)]
        pub unsafe fn animateWithDuration_delay_usingSpringWithDamping_initialSpringVelocity_options_animations_completion(
            duration: NSTimeInterval,
            delay: NSTimeInterval,
            damping_ratio: CGFloat,
            velocity: CGFloat,
            options: UIViewAnimationOptions,
            animations: &block2::Block<dyn Fn()>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(transitionWithView:duration:options:animations:completion:)]
        pub unsafe fn transitionWithView_duration_options_animations_completion(
            view: &UIView,
            duration: NSTimeInterval,
            options: UIViewAnimationOptions,
            animations: Option<&block2::Block<dyn Fn()>>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
        );

        #[cfg(feature = "block2")]
        #[method(transitionFromView:toView:duration:options:completion:)]
        pub unsafe fn transitionFromView_toView_duration_options_completion(
            from_view: &UIView,
            to_view: &UIView,
            duration: NSTimeInterval,
            options: UIViewAnimationOptions,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
        );

        #[cfg(feature = "block2")]
        #[method(performSystemAnimation:onViews:options:animations:completion:)]
        pub unsafe fn performSystemAnimation_onViews_options_animations_completion(
            animation: UISystemAnimation,
            views: &NSArray<UIView>,
            options: UIViewAnimationOptions,
            parallel_animations: Option<&block2::Block<dyn Fn()>>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(modifyAnimationsWithRepeatCount:autoreverses:animations:)]
        pub unsafe fn modifyAnimationsWithRepeatCount_autoreverses_animations(
            count: CGFloat,
            autoreverses: bool,
            animations: &block2::Block<dyn Fn() + '_>,
            mtm: MainThreadMarker,
        );
    }
);

extern_methods!(
    /// UIViewKeyframeAnimations
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "block2")]
        #[method(animateKeyframesWithDuration:delay:options:animations:completion:)]
        pub unsafe fn animateKeyframesWithDuration_delay_options_animations_completion(
            duration: NSTimeInterval,
            delay: NSTimeInterval,
            options: UIViewKeyframeAnimationOptions,
            animations: &block2::Block<dyn Fn()>,
            completion: Option<&block2::Block<dyn Fn(Bool)>>,
            mtm: MainThreadMarker,
        );

        #[cfg(feature = "block2")]
        #[method(addKeyframeWithRelativeStartTime:relativeDuration:animations:)]
        pub unsafe fn addKeyframeWithRelativeStartTime_relativeDuration_animations(
            frame_start_time: c_double,
            frame_duration: c_double,
            animations: &block2::Block<dyn Fn()>,
            mtm: MainThreadMarker,
        );
    }
);

extern_methods!(
    /// UIViewGestureRecognizers
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UIGestureRecognizer")]
        #[method_id(@__retain_semantics Other gestureRecognizers)]
        pub fn gestureRecognizers(&self) -> Option<Retained<NSArray<UIGestureRecognizer>>>;

        #[cfg(feature = "UIGestureRecognizer")]
        #[method(setGestureRecognizers:)]
        pub unsafe fn setGestureRecognizers(
            &self,
            gesture_recognizers: Option<&NSArray<UIGestureRecognizer>>,
        );

        #[cfg(feature = "UIGestureRecognizer")]
        #[method(addGestureRecognizer:)]
        pub fn addGestureRecognizer(&self, gesture_recognizer: &UIGestureRecognizer);

        #[cfg(feature = "UIGestureRecognizer")]
        #[method(removeGestureRecognizer:)]
        pub fn removeGestureRecognizer(&self, gesture_recognizer: &UIGestureRecognizer);

        #[cfg(feature = "UIGestureRecognizer")]
        #[method(gestureRecognizerShouldBegin:)]
        pub fn gestureRecognizerShouldBegin(
            &self,
            gesture_recognizer: &UIGestureRecognizer,
        ) -> bool;
    }
);

extern_methods!(
    /// UIViewMotionEffects
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UIMotionEffect")]
        #[method(addMotionEffect:)]
        pub unsafe fn addMotionEffect(&self, effect: &UIMotionEffect);

        #[cfg(feature = "UIMotionEffect")]
        #[method(removeMotionEffect:)]
        pub unsafe fn removeMotionEffect(&self, effect: &UIMotionEffect);

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

        #[cfg(feature = "UIMotionEffect")]
        #[method(setMotionEffects:)]
        pub unsafe fn setMotionEffects(&self, motion_effects: &NSArray<UIMotionEffect>);
    }
);

// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UILayoutConstraintAxis(pub NSInteger);
impl UILayoutConstraintAxis {
    #[doc(alias = "UILayoutConstraintAxisHorizontal")]
    pub const Horizontal: Self = Self(0);
    #[doc(alias = "UILayoutConstraintAxisVertical")]
    pub const Vertical: Self = Self(1);
}

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

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

extern_methods!(
    /// UIConstraintBasedLayoutInstallingConstraints
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "NSLayoutConstraint")]
        #[method_id(@__retain_semantics Other constraints)]
        pub unsafe fn constraints(&self) -> Retained<NSArray<NSLayoutConstraint>>;

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(addConstraint:)]
        pub unsafe fn addConstraint(&self, constraint: &NSLayoutConstraint);

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(addConstraints:)]
        pub unsafe fn addConstraints(&self, constraints: &NSArray<NSLayoutConstraint>);

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(removeConstraint:)]
        pub unsafe fn removeConstraint(&self, constraint: &NSLayoutConstraint);

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(removeConstraints:)]
        pub unsafe fn removeConstraints(&self, constraints: &NSArray<NSLayoutConstraint>);
    }
);

extern_methods!(
    /// UIConstraintBasedLayoutCoreMethods
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(updateConstraintsIfNeeded)]
        pub unsafe fn updateConstraintsIfNeeded(&self);

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

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

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

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

        #[method(setTranslatesAutoresizingMaskIntoConstraints:)]
        pub unsafe fn setTranslatesAutoresizingMaskIntoConstraints(
            &self,
            translates_autoresizing_mask_into_constraints: bool,
        );

        #[method(requiresConstraintBasedLayout)]
        pub unsafe fn requiresConstraintBasedLayout(mtm: MainThreadMarker) -> bool;
    }
);

extern "C" {
    pub static UIViewNoIntrinsicMetric: CGFloat;
}

extern_methods!(
    /// UIConstraintBasedLayoutLayering
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(alignmentRectForFrame:)]
        pub unsafe fn alignmentRectForFrame(&self, frame: CGRect) -> CGRect;

        #[method(frameForAlignmentRect:)]
        pub unsafe fn frameForAlignmentRect(&self, alignment_rect: CGRect) -> CGRect;

        #[cfg(feature = "UIGeometry")]
        #[method(alignmentRectInsets)]
        pub unsafe fn alignmentRectInsets(&self) -> UIEdgeInsets;

        #[deprecated = "Override -viewForFirstBaselineLayout or -viewForLastBaselineLayout as appropriate, instead"]
        #[method_id(@__retain_semantics Other viewForBaselineLayout)]
        pub unsafe fn viewForBaselineLayout(&self) -> Retained<UIView>;

        #[method_id(@__retain_semantics Other viewForFirstBaselineLayout)]
        pub unsafe fn viewForFirstBaselineLayout(&self) -> Retained<UIView>;

        #[method_id(@__retain_semantics Other viewForLastBaselineLayout)]
        pub unsafe fn viewForLastBaselineLayout(&self) -> Retained<UIView>;

        #[method(intrinsicContentSize)]
        pub unsafe fn intrinsicContentSize(&self) -> CGSize;

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

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(contentHuggingPriorityForAxis:)]
        pub unsafe fn contentHuggingPriorityForAxis(
            &self,
            axis: UILayoutConstraintAxis,
        ) -> UILayoutPriority;

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(setContentHuggingPriority:forAxis:)]
        pub unsafe fn setContentHuggingPriority_forAxis(
            &self,
            priority: UILayoutPriority,
            axis: UILayoutConstraintAxis,
        );

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(contentCompressionResistancePriorityForAxis:)]
        pub unsafe fn contentCompressionResistancePriorityForAxis(
            &self,
            axis: UILayoutConstraintAxis,
        ) -> UILayoutPriority;

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(setContentCompressionResistancePriority:forAxis:)]
        pub unsafe fn setContentCompressionResistancePriority_forAxis(
            &self,
            priority: UILayoutPriority,
            axis: UILayoutConstraintAxis,
        );
    }
);

extern "C" {
    pub static UILayoutFittingCompressedSize: CGSize;
}

extern "C" {
    pub static UILayoutFittingExpandedSize: CGSize;
}

extern_methods!(
    /// UIConstraintBasedLayoutFittingSize
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method(systemLayoutSizeFittingSize:)]
        pub unsafe fn systemLayoutSizeFittingSize(&self, target_size: CGSize) -> CGSize;

        #[cfg(feature = "NSLayoutConstraint")]
        #[method(systemLayoutSizeFittingSize:withHorizontalFittingPriority:verticalFittingPriority:)]
        pub unsafe fn systemLayoutSizeFittingSize_withHorizontalFittingPriority_verticalFittingPriority(
            &self,
            target_size: CGSize,
            horizontal_fitting_priority: UILayoutPriority,
            vertical_fitting_priority: UILayoutPriority,
        ) -> CGSize;
    }
);

extern_methods!(
    /// UILayoutGuideSupport
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UILayoutGuide")]
        #[method_id(@__retain_semantics Other layoutGuides)]
        pub unsafe fn layoutGuides(&self) -> Retained<NSArray<UILayoutGuide>>;

        #[cfg(feature = "UILayoutGuide")]
        #[method(addLayoutGuide:)]
        pub unsafe fn addLayoutGuide(&self, layout_guide: &UILayoutGuide);

        #[cfg(feature = "UILayoutGuide")]
        #[method(removeLayoutGuide:)]
        pub unsafe fn removeLayoutGuide(&self, layout_guide: &UILayoutGuide);
    }
);

extern_methods!(
    /// UIViewLayoutConstraintCreation
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "NSLayoutAnchor")]
        #[method_id(@__retain_semantics Other leadingAnchor)]
        pub unsafe fn leadingAnchor(&self) -> Retained<NSLayoutXAxisAnchor>;

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

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

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

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

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

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

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

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

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

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

        #[cfg(feature = "NSLayoutAnchor")]
        #[method_id(@__retain_semantics Other lastBaselineAnchor)]
        pub unsafe fn lastBaselineAnchor(&self) -> Retained<NSLayoutYAxisAnchor>;
    }
);

extern_methods!(
    /// UIConstraintBasedLayoutDebugging
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "NSLayoutConstraint")]
        #[method_id(@__retain_semantics Other constraintsAffectingLayoutForAxis:)]
        pub unsafe fn constraintsAffectingLayoutForAxis(
            &self,
            axis: UILayoutConstraintAxis,
        ) -> Retained<NSArray<NSLayoutConstraint>>;

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

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

extern_methods!(
    /// UIConstraintBasedLayoutDebugging
    #[cfg(feature = "UILayoutGuide")]
    unsafe impl UILayoutGuide {
        #[cfg(feature = "NSLayoutConstraint")]
        #[method_id(@__retain_semantics Other constraintsAffectingLayoutForAxis:)]
        pub unsafe fn constraintsAffectingLayoutForAxis(
            &self,
            axis: UILayoutConstraintAxis,
        ) -> Retained<NSArray<NSLayoutConstraint>>;

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

extern_methods!(
    /// UIStateRestoration
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method_id(@__retain_semantics Other restorationIdentifier)]
        pub unsafe fn restorationIdentifier(&self) -> Option<Retained<NSString>>;

        #[method(setRestorationIdentifier:)]
        pub unsafe fn setRestorationIdentifier(&self, restoration_identifier: Option<&NSString>);

        #[method(encodeRestorableStateWithCoder:)]
        pub unsafe fn encodeRestorableStateWithCoder(&self, coder: &NSCoder);

        #[method(decodeRestorableStateWithCoder:)]
        pub unsafe fn decodeRestorableStateWithCoder(&self, coder: &NSCoder);
    }
);

extern_methods!(
    /// UISnapshotting
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[method_id(@__retain_semantics Other snapshotViewAfterScreenUpdates:)]
        pub unsafe fn snapshotViewAfterScreenUpdates(
            &self,
            after_updates: bool,
        ) -> Option<Retained<UIView>>;

        #[cfg(feature = "UIGeometry")]
        #[method_id(@__retain_semantics Other resizableSnapshotViewFromRect:afterScreenUpdates:withCapInsets:)]
        pub unsafe fn resizableSnapshotViewFromRect_afterScreenUpdates_withCapInsets(
            &self,
            rect: CGRect,
            after_updates: bool,
            cap_insets: UIEdgeInsets,
        ) -> Option<Retained<UIView>>;

        #[method(drawViewHierarchyInRect:afterScreenUpdates:)]
        pub unsafe fn drawViewHierarchyInRect_afterScreenUpdates(
            &self,
            rect: CGRect,
            after_updates: bool,
        ) -> bool;
    }
);

extern_methods!(
    /// DeprecatedAnimations
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[deprecated = "Use the block-based animation API instead"]
        #[method(beginAnimations:context:)]
        pub unsafe fn beginAnimations_context(
            animation_id: Option<&NSString>,
            context: *mut c_void,
            mtm: MainThreadMarker,
        );

        #[deprecated = "Use the block-based animation API instead"]
        #[method(commitAnimations)]
        pub unsafe fn commitAnimations(mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationDelegate:)]
        pub unsafe fn setAnimationDelegate(delegate: Option<&AnyObject>, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationWillStartSelector:)]
        pub unsafe fn setAnimationWillStartSelector(selector: Option<Sel>, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationDidStopSelector:)]
        pub unsafe fn setAnimationDidStopSelector(selector: Option<Sel>, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationDuration:)]
        pub unsafe fn setAnimationDuration(duration: NSTimeInterval, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationDelay:)]
        pub unsafe fn setAnimationDelay(delay: NSTimeInterval, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationStartDate:)]
        pub unsafe fn setAnimationStartDate(start_date: &NSDate, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationCurve:)]
        pub unsafe fn setAnimationCurve(curve: UIViewAnimationCurve, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationRepeatCount:)]
        pub unsafe fn setAnimationRepeatCount(repeat_count: c_float, mtm: MainThreadMarker);

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationRepeatAutoreverses:)]
        pub unsafe fn setAnimationRepeatAutoreverses(
            repeat_autoreverses: bool,
            mtm: MainThreadMarker,
        );

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationBeginsFromCurrentState:)]
        pub unsafe fn setAnimationBeginsFromCurrentState(
            from_current_state: bool,
            mtm: MainThreadMarker,
        );

        #[deprecated = "Use the block-based animation API instead"]
        #[method(setAnimationTransition:forView:cache:)]
        pub unsafe fn setAnimationTransition_forView_cache(
            transition: UIViewAnimationTransition,
            view: &UIView,
            cache: bool,
        );
    }
);

extern_methods!(
    /// UserInterfaceStyle
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UIInterface")]
        #[method(overrideUserInterfaceStyle)]
        pub unsafe fn overrideUserInterfaceStyle(&self) -> UIUserInterfaceStyle;

        #[cfg(feature = "UIInterface")]
        #[method(setOverrideUserInterfaceStyle:)]
        pub unsafe fn setOverrideUserInterfaceStyle(
            &self,
            override_user_interface_style: UIUserInterfaceStyle,
        );
    }
);

extern_methods!(
    /// UIContentSizeCategoryLimit
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UIContentSizeCategory")]
        #[method_id(@__retain_semantics Other minimumContentSizeCategory)]
        pub unsafe fn minimumContentSizeCategory(&self) -> Option<Retained<UIContentSizeCategory>>;

        #[cfg(feature = "UIContentSizeCategory")]
        #[method(setMinimumContentSizeCategory:)]
        pub unsafe fn setMinimumContentSizeCategory(
            &self,
            minimum_content_size_category: Option<&UIContentSizeCategory>,
        );

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

        #[cfg(feature = "UIContentSizeCategory")]
        #[method(setMaximumContentSizeCategory:)]
        pub unsafe fn setMaximumContentSizeCategory(
            &self,
            maximum_content_size_category: Option<&UIContentSizeCategory>,
        );

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

extern_methods!(
    #[cfg(feature = "UIResponder")]
    unsafe impl UIView {
        #[cfg(feature = "UITraitCollection")]
        #[method_id(@__retain_semantics Other traitOverrides)]
        pub unsafe fn traitOverrides(&self) -> Retained<ProtocolObject<dyn UITraitOverrides>>;

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

#[cfg(all(feature = "UIResponder", feature = "UITraitCollection"))]
unsafe impl UITraitChangeObservable for UIView {}
