objc2-ui-kit 0.3.2

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-core-foundation")]
use objc2_core_foundation::*;
use objc2_foundation::*;

use crate::*;

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/uiedgeinsets?language=objc)
#[cfg(feature = "objc2-core-foundation")]
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct UIEdgeInsets {
    pub top: CGFloat,
    pub left: CGFloat,
    pub bottom: CGFloat,
    pub right: CGFloat,
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Encode for UIEdgeInsets {
    const ENCODING: Encoding = Encoding::Struct(
        "UIEdgeInsets",
        &[
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
        ],
    );
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl RefEncode for UIEdgeInsets {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Send for UIEdgeInsets {}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Sync for UIEdgeInsets {}

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/nsdirectionaledgeinsets?language=objc)
#[cfg(feature = "objc2-core-foundation")]
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NSDirectionalEdgeInsets {
    pub top: CGFloat,
    pub leading: CGFloat,
    pub bottom: CGFloat,
    pub trailing: CGFloat,
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Encode for NSDirectionalEdgeInsets {
    const ENCODING: Encoding = Encoding::Struct(
        "NSDirectionalEdgeInsets",
        &[
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
        ],
    );
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl RefEncode for NSDirectionalEdgeInsets {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Send for NSDirectionalEdgeInsets {}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Sync for NSDirectionalEdgeInsets {}

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/uioffset?language=objc)
#[cfg(feature = "objc2-core-foundation")]
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct UIOffset {
    pub horizontal: CGFloat,
    pub vertical: CGFloat,
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Encode for UIOffset {
    const ENCODING: Encoding =
        Encoding::Struct("UIOffset", &[<CGFloat>::ENCODING, <CGFloat>::ENCODING]);
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl RefEncode for UIOffset {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Send for UIOffset {}

#[cfg(feature = "objc2-core-foundation")]
unsafe impl Sync for UIOffset {}

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/uirectcorner?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIRectCorner(pub NSUInteger);
bitflags::bitflags! {
    impl UIRectCorner: NSUInteger {
        #[doc(alias = "UIRectCornerTopLeft")]
        const TopLeft = 1<<0;
        #[doc(alias = "UIRectCornerTopRight")]
        const TopRight = 1<<1;
        #[doc(alias = "UIRectCornerBottomLeft")]
        const BottomLeft = 1<<2;
        #[doc(alias = "UIRectCornerBottomRight")]
        const BottomRight = 1<<3;
        #[doc(alias = "UIRectCornerAllCorners")]
        const AllCorners = !0;
    }
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/nsdirectionalrectedge?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct NSDirectionalRectEdge(pub NSUInteger);
bitflags::bitflags! {
    impl NSDirectionalRectEdge: NSUInteger {
        #[doc(alias = "NSDirectionalRectEdgeNone")]
        const None = 0;
        #[doc(alias = "NSDirectionalRectEdgeTop")]
        const Top = 1<<0;
        #[doc(alias = "NSDirectionalRectEdgeLeading")]
        const Leading = 1<<1;
        #[doc(alias = "NSDirectionalRectEdgeBottom")]
        const Bottom = 1<<2;
        #[doc(alias = "NSDirectionalRectEdgeTrailing")]
        const Trailing = 1<<3;
        #[doc(alias = "NSDirectionalRectEdgeAll")]
        const All = NSDirectionalRectEdge::Top.0|NSDirectionalRectEdge::Leading.0|NSDirectionalRectEdge::Bottom.0|NSDirectionalRectEdge::Trailing.0;
    }
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/uidirectionalrectedge?language=objc)
// NS_OPTIONS
#[deprecated]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIDirectionalRectEdge(pub NSUInteger);
bitflags::bitflags! {
    impl UIDirectionalRectEdge: NSUInteger {
        #[doc(alias = "UIDirectionalRectEdgeNone")]
#[deprecated]
        const None = 0;
        #[doc(alias = "UIDirectionalRectEdgeTop")]
#[deprecated]
        const Top = 1<<0;
        #[doc(alias = "UIDirectionalRectEdgeLeading")]
#[deprecated]
        const Leading = 1<<1;
        #[doc(alias = "UIDirectionalRectEdgeBottom")]
#[deprecated]
        const Bottom = 1<<2;
        #[doc(alias = "UIDirectionalRectEdgeTrailing")]
#[deprecated]
        const Trailing = 1<<3;
        #[doc(alias = "UIDirectionalRectEdgeAll")]
#[deprecated]
        const All = UIDirectionalRectEdge::Top.0|UIDirectionalRectEdge::Leading.0|UIDirectionalRectEdge::Bottom.0|UIDirectionalRectEdge::Trailing.0;
    }
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/uikit/nsrectalignment?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct NSRectAlignment(pub NSInteger);
impl NSRectAlignment {
    #[doc(alias = "NSRectAlignmentNone")]
    pub const None: Self = Self(0);
    #[doc(alias = "NSRectAlignmentTop")]
    pub const Top: Self = Self(1);
    #[doc(alias = "NSRectAlignmentTopLeading")]
    pub const TopLeading: Self = Self(2);
    #[doc(alias = "NSRectAlignmentLeading")]
    pub const Leading: Self = Self(3);
    #[doc(alias = "NSRectAlignmentBottomLeading")]
    pub const BottomLeading: Self = Self(4);
    #[doc(alias = "NSRectAlignmentBottom")]
    pub const Bottom: Self = Self(5);
    #[doc(alias = "NSRectAlignmentBottomTrailing")]
    pub const BottomTrailing: Self = Self(6);
    #[doc(alias = "NSRectAlignmentTrailing")]
    pub const Trailing: Self = Self(7);
    #[doc(alias = "NSRectAlignmentTopTrailing")]
    pub const TopTrailing: Self = Self(8);
}

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

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

#[cfg(feature = "objc2-core-foundation")]
impl UIEdgeInsets {
    // TODO: pub fn UIEdgeInsetsMake(top: CGFloat,left: CGFloat,bottom: CGFloat,right: CGFloat,) -> UIEdgeInsets;
}

#[cfg(feature = "objc2-core-foundation")]
impl NSDirectionalEdgeInsets {
    // TODO: pub fn NSDirectionalEdgeInsetsMake(top: CGFloat,leading: CGFloat,bottom: CGFloat,trailing: CGFloat,) -> NSDirectionalEdgeInsets;
}

#[cfg(feature = "objc2-core-foundation")]
impl UIEdgeInsets {
    // TODO: pub fn UIEdgeInsetsInsetRect(rect: CGRect,insets: UIEdgeInsets,) -> CGRect;
}

#[cfg(feature = "objc2-core-foundation")]
impl UIOffset {
    // TODO: pub fn UIOffsetMake(horizontal: CGFloat,vertical: CGFloat,) -> UIOffset;
}

#[cfg(feature = "objc2-core-foundation")]
impl UIEdgeInsets {
    // TODO: pub fn UIEdgeInsetsEqualToEdgeInsets(insets1: UIEdgeInsets,insets2: UIEdgeInsets,) -> Bool;
}

#[cfg(feature = "objc2-core-foundation")]
impl NSDirectionalEdgeInsets {
    // TODO: pub fn NSDirectionalEdgeInsetsEqualToDirectionalEdgeInsets(insets1: NSDirectionalEdgeInsets,insets2: NSDirectionalEdgeInsets,) -> Bool;
}

#[cfg(feature = "objc2-core-foundation")]
impl UIOffset {
    // TODO: pub fn UIOffsetEqualToOffset(offset1: UIOffset,offset2: UIOffset,) -> Bool;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/uikit/uiedgeinsetszero?language=objc)
    #[cfg(feature = "objc2-core-foundation")]
    pub static UIEdgeInsetsZero: UIEdgeInsets;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/uikit/nsdirectionaledgeinsetszero?language=objc)
    #[cfg(feature = "objc2-core-foundation")]
    pub static NSDirectionalEdgeInsetsZero: NSDirectionalEdgeInsets;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/uikit/uioffsetzero?language=objc)
    #[cfg(feature = "objc2-core-foundation")]
    pub static UIOffsetZero: UIOffset;
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromCGPoint(point: CGPoint) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromCGPoint(point: CGPoint) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromCGPoint(point) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromCGVector(vector: CGVector) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromCGVector(vector: CGVector) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromCGVector(vector) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromCGSize(size: CGSize) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromCGSize(size: CGSize) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromCGSize(size) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromCGRect(rect: CGRect) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromCGRect(rect: CGRect) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromCGRect(rect) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromCGAffineTransform(
    transform: CGAffineTransform,
) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromCGAffineTransform(transform: CGAffineTransform) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromCGAffineTransform(transform) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromUIEdgeInsets(insets: UIEdgeInsets) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromUIEdgeInsets(insets: UIEdgeInsets) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromUIEdgeInsets(insets) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromDirectionalEdgeInsets(
    insets: NSDirectionalEdgeInsets,
) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromDirectionalEdgeInsets(insets: NSDirectionalEdgeInsets) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromDirectionalEdgeInsets(insets) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn NSStringFromUIOffset(offset: UIOffset) -> Retained<NSString> {
    extern "C-unwind" {
        fn NSStringFromUIOffset(offset: UIOffset) -> *mut NSString;
    }
    let ret = unsafe { NSStringFromUIOffset(offset) };
    unsafe { Retained::retain_autoreleased(ret) }
        .expect("function was marked as returning non-null, but actually returned NULL")
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn CGPointFromString(string: &NSString) -> CGPoint {
    extern "C-unwind" {
        fn CGPointFromString(string: &NSString) -> CGPoint;
    }
    unsafe { CGPointFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn CGVectorFromString(string: &NSString) -> CGVector {
    extern "C-unwind" {
        fn CGVectorFromString(string: &NSString) -> CGVector;
    }
    unsafe { CGVectorFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn CGSizeFromString(string: &NSString) -> CGSize {
    extern "C-unwind" {
        fn CGSizeFromString(string: &NSString) -> CGSize;
    }
    unsafe { CGSizeFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn CGRectFromString(string: &NSString) -> CGRect {
    extern "C-unwind" {
        fn CGRectFromString(string: &NSString) -> CGRect;
    }
    unsafe { CGRectFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[inline]
pub extern "C-unwind" fn CGAffineTransformFromString(string: &NSString) -> CGAffineTransform {
    extern "C-unwind" {
        fn CGAffineTransformFromString(string: &NSString) -> CGAffineTransform;
    }
    unsafe { CGAffineTransformFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
impl UIEdgeInsets {
    #[doc(alias = "UIEdgeInsetsFromString")]
    #[cfg(feature = "objc2-core-foundation")]
    #[inline]
    pub fn from_string(string: &NSString) -> UIEdgeInsets {
        extern "C-unwind" {
            fn UIEdgeInsetsFromString(string: &NSString) -> UIEdgeInsets;
        }
        unsafe { UIEdgeInsetsFromString(string) }
    }
}

#[cfg(feature = "objc2-core-foundation")]
impl NSDirectionalEdgeInsets {
    #[doc(alias = "NSDirectionalEdgeInsetsFromString")]
    #[cfg(feature = "objc2-core-foundation")]
    #[inline]
    pub fn from_string(string: &NSString) -> NSDirectionalEdgeInsets {
        extern "C-unwind" {
            fn NSDirectionalEdgeInsetsFromString(string: &NSString) -> NSDirectionalEdgeInsets;
        }
        unsafe { NSDirectionalEdgeInsetsFromString(string) }
    }
}

#[cfg(feature = "objc2-core-foundation")]
impl UIOffset {
    #[doc(alias = "UIOffsetFromString")]
    #[cfg(feature = "objc2-core-foundation")]
    #[inline]
    pub fn from_string(string: &NSString) -> UIOffset {
        extern "C-unwind" {
            fn UIOffsetFromString(string: &NSString) -> UIOffset;
        }
        unsafe { UIOffsetFromString(string) }
    }
}

mod private_NSValueUIGeometryExtensions {
    pub trait Sealed {}
}

/// Category on [`NSValue`].
pub unsafe trait NSValueUIGeometryExtensions:
    ClassType + Sized + private_NSValueUIGeometryExtensions::Sealed
{
    extern_methods!(
        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithCGPoint:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithCGPoint(point: CGPoint) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithCGVector:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithCGVector(vector: CGVector) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithCGSize:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithCGSize(size: CGSize) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithCGRect:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithCGRect(rect: CGRect) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithCGAffineTransform:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithCGAffineTransform(transform: CGAffineTransform) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithUIEdgeInsets:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithUIEdgeInsets(insets: UIEdgeInsets) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithDirectionalEdgeInsets:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithDirectionalEdgeInsets(
            insets: NSDirectionalEdgeInsets,
        ) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(valueWithUIOffset:))]
        #[unsafe(method_family = none)]
        unsafe fn valueWithUIOffset(insets: UIOffset) -> Retained<NSValue>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(CGPointValue))]
        #[unsafe(method_family = none)]
        unsafe fn CGPointValue(&self) -> CGPoint;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(CGVectorValue))]
        #[unsafe(method_family = none)]
        unsafe fn CGVectorValue(&self) -> CGVector;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(CGSizeValue))]
        #[unsafe(method_family = none)]
        unsafe fn CGSizeValue(&self) -> CGSize;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(CGRectValue))]
        #[unsafe(method_family = none)]
        unsafe fn CGRectValue(&self) -> CGRect;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(CGAffineTransformValue))]
        #[unsafe(method_family = none)]
        unsafe fn CGAffineTransformValue(&self) -> CGAffineTransform;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(UIEdgeInsetsValue))]
        #[unsafe(method_family = none)]
        unsafe fn UIEdgeInsetsValue(&self) -> UIEdgeInsets;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(directionalEdgeInsetsValue))]
        #[unsafe(method_family = none)]
        unsafe fn directionalEdgeInsetsValue(&self) -> NSDirectionalEdgeInsets;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(UIOffsetValue))]
        #[unsafe(method_family = none)]
        unsafe fn UIOffsetValue(&self) -> UIOffset;
    );
}

impl private_NSValueUIGeometryExtensions::Sealed for NSValue {}
unsafe impl NSValueUIGeometryExtensions for NSValue {}

mod private_NSCoderUIGeometryKeyedCoding {
    pub trait Sealed {}
}

/// Category "UIGeometryKeyedCoding" on [`NSCoder`].
#[doc(alias = "UIGeometryKeyedCoding")]
pub unsafe trait NSCoderUIGeometryKeyedCoding:
    ClassType + Sized + private_NSCoderUIGeometryKeyedCoding::Sealed
{
    extern_methods!(
        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeCGPoint:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeCGPoint_forKey(&self, point: CGPoint, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeCGVector:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeCGVector_forKey(&self, vector: CGVector, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeCGSize:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeCGSize_forKey(&self, size: CGSize, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeCGRect:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeCGRect_forKey(&self, rect: CGRect, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeCGAffineTransform:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeCGAffineTransform_forKey(&self, transform: CGAffineTransform, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeUIEdgeInsets:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeUIEdgeInsets_forKey(&self, insets: UIEdgeInsets, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeDirectionalEdgeInsets:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeDirectionalEdgeInsets_forKey(
            &self,
            insets: NSDirectionalEdgeInsets,
            key: &NSString,
        );

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(encodeUIOffset:forKey:))]
        #[unsafe(method_family = none)]
        fn encodeUIOffset_forKey(&self, offset: UIOffset, key: &NSString);

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeCGPointForKey:))]
        #[unsafe(method_family = none)]
        fn decodeCGPointForKey(&self, key: &NSString) -> CGPoint;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeCGVectorForKey:))]
        #[unsafe(method_family = none)]
        fn decodeCGVectorForKey(&self, key: &NSString) -> CGVector;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeCGSizeForKey:))]
        #[unsafe(method_family = none)]
        fn decodeCGSizeForKey(&self, key: &NSString) -> CGSize;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeCGRectForKey:))]
        #[unsafe(method_family = none)]
        fn decodeCGRectForKey(&self, key: &NSString) -> CGRect;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeCGAffineTransformForKey:))]
        #[unsafe(method_family = none)]
        fn decodeCGAffineTransformForKey(&self, key: &NSString) -> CGAffineTransform;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeUIEdgeInsetsForKey:))]
        #[unsafe(method_family = none)]
        fn decodeUIEdgeInsetsForKey(&self, key: &NSString) -> UIEdgeInsets;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeDirectionalEdgeInsetsForKey:))]
        #[unsafe(method_family = none)]
        fn decodeDirectionalEdgeInsetsForKey(&self, key: &NSString) -> NSDirectionalEdgeInsets;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(decodeUIOffsetForKey:))]
        #[unsafe(method_family = none)]
        fn decodeUIOffsetForKey(&self, key: &NSString) -> UIOffset;
    );
}

impl private_NSCoderUIGeometryKeyedCoding::Sealed for NSCoder {}
unsafe impl NSCoderUIGeometryKeyedCoding for NSCoder {}

#[cfg(feature = "objc2-core-foundation")]
#[deprecated = "renamed to `UIEdgeInsets::from_string`"]
#[inline]
pub extern "C-unwind" fn UIEdgeInsetsFromString(string: &NSString) -> UIEdgeInsets {
    extern "C-unwind" {
        fn UIEdgeInsetsFromString(string: &NSString) -> UIEdgeInsets;
    }
    unsafe { UIEdgeInsetsFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[deprecated = "renamed to `NSDirectionalEdgeInsets::from_string`"]
#[inline]
pub extern "C-unwind" fn NSDirectionalEdgeInsetsFromString(
    string: &NSString,
) -> NSDirectionalEdgeInsets {
    extern "C-unwind" {
        fn NSDirectionalEdgeInsetsFromString(string: &NSString) -> NSDirectionalEdgeInsets;
    }
    unsafe { NSDirectionalEdgeInsetsFromString(string) }
}

#[cfg(feature = "objc2-core-foundation")]
#[deprecated = "renamed to `UIOffset::from_string`"]
#[inline]
pub extern "C-unwind" fn UIOffsetFromString(string: &NSString) -> UIOffset {
    extern "C-unwind" {
        fn UIOffsetFromString(string: &NSString) -> UIOffset;
    }
    unsafe { UIOffsetFromString(string) }
}