objc2-security 0.3.2

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

use crate::*;

/// [Apple's documentation](https://developer.apple.com/documentation/security/ksecunlockstatestatus?language=objc)
pub const kSecUnlockStateStatus: u32 = 1;
/// [Apple's documentation](https://developer.apple.com/documentation/security/ksecreadpermstatus?language=objc)
pub const kSecReadPermStatus: u32 = 2;
/// [Apple's documentation](https://developer.apple.com/documentation/security/ksecwritepermstatus?language=objc)
pub const kSecWritePermStatus: u32 = 4;

/// Contains keychain settings.
/// Field: version An unsigned 32-bit integer representing the keychain version.
/// Field: lockOnSleep A boolean value indicating whether the keychain locks when the system sleeps.
/// Field: useLockInterval A boolean value indicating whether the keychain automatically locks after a certain period of time.
/// Field: lockInterval An unsigned 32-bit integer representing the number of seconds before the keychain locks.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/seckeychainsettings?language=objc)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SecKeychainSettings {
    pub version: u32,
    pub lockOnSleep: Boolean,
    pub useLockInterval: Boolean,
    pub lockInterval: u32,
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecKeychainSettings {
    const ENCODING: Encoding = Encoding::Struct(
        "SecKeychainSettings",
        &[
            <u32>::ENCODING,
            <Boolean>::ENCODING,
            <Boolean>::ENCODING,
            <u32>::ENCODING,
        ],
    );
}

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

/// [Apple's documentation](https://developer.apple.com/documentation/security/secauthenticationtype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SecAuthenticationType(pub FourCharCode);
impl SecAuthenticationType {
    #[doc(alias = "kSecAuthenticationTypeNTLM")]
    pub const NTLM: Self = Self(AUTH_TYPE_FIX_!(0x6e746c6d));
    #[doc(alias = "kSecAuthenticationTypeMSN")]
    pub const MSN: Self = Self(AUTH_TYPE_FIX_!(0x6d736e61));
    #[doc(alias = "kSecAuthenticationTypeDPA")]
    pub const DPA: Self = Self(AUTH_TYPE_FIX_!(0x64706161));
    #[doc(alias = "kSecAuthenticationTypeRPA")]
    pub const RPA: Self = Self(AUTH_TYPE_FIX_!(0x72706161));
    #[doc(alias = "kSecAuthenticationTypeHTTPBasic")]
    pub const HTTPBasic: Self = Self(AUTH_TYPE_FIX_!(0x68747470));
    #[doc(alias = "kSecAuthenticationTypeHTTPDigest")]
    pub const HTTPDigest: Self = Self(AUTH_TYPE_FIX_!(0x68747464));
    #[doc(alias = "kSecAuthenticationTypeHTMLForm")]
    pub const HTMLForm: Self = Self(AUTH_TYPE_FIX_!(0x666f726d));
    #[doc(alias = "kSecAuthenticationTypeDefault")]
    pub const Default: Self = Self(AUTH_TYPE_FIX_!(0x64666c74));
    #[doc(alias = "kSecAuthenticationTypeAny")]
    pub const Any: Self = Self(AUTH_TYPE_FIX_!(0));
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecAuthenticationType {
    const ENCODING: Encoding = FourCharCode::ENCODING;
}

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

/// Defines the protocol type associated with an AppleShare or Internet password.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/secprotocoltype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SecProtocolType(pub FourCharCode);
impl SecProtocolType {
    #[doc(alias = "kSecProtocolTypeFTP")]
    pub const FTP: Self = Self(0x66747020);
    #[doc(alias = "kSecProtocolTypeFTPAccount")]
    pub const FTPAccount: Self = Self(0x66747061);
    #[doc(alias = "kSecProtocolTypeHTTP")]
    pub const HTTP: Self = Self(0x68747470);
    #[doc(alias = "kSecProtocolTypeIRC")]
    pub const IRC: Self = Self(0x69726320);
    #[doc(alias = "kSecProtocolTypeNNTP")]
    pub const NNTP: Self = Self(0x6e6e7470);
    #[doc(alias = "kSecProtocolTypePOP3")]
    pub const POP3: Self = Self(0x706f7033);
    #[doc(alias = "kSecProtocolTypeSMTP")]
    pub const SMTP: Self = Self(0x736d7470);
    #[doc(alias = "kSecProtocolTypeSOCKS")]
    pub const SOCKS: Self = Self(0x736f7820);
    #[doc(alias = "kSecProtocolTypeIMAP")]
    pub const IMAP: Self = Self(0x696d6170);
    #[doc(alias = "kSecProtocolTypeLDAP")]
    pub const LDAP: Self = Self(0x6c646170);
    #[doc(alias = "kSecProtocolTypeAppleTalk")]
    pub const AppleTalk: Self = Self(0x61746c6b);
    #[doc(alias = "kSecProtocolTypeAFP")]
    pub const AFP: Self = Self(0x61667020);
    #[doc(alias = "kSecProtocolTypeTelnet")]
    pub const Telnet: Self = Self(0x74656c6e);
    #[doc(alias = "kSecProtocolTypeSSH")]
    pub const SSH: Self = Self(0x73736820);
    #[doc(alias = "kSecProtocolTypeFTPS")]
    pub const FTPS: Self = Self(0x66747073);
    #[doc(alias = "kSecProtocolTypeHTTPS")]
    pub const HTTPS: Self = Self(0x68747073);
    #[doc(alias = "kSecProtocolTypeHTTPProxy")]
    pub const HTTPProxy: Self = Self(0x68747078);
    #[doc(alias = "kSecProtocolTypeHTTPSProxy")]
    pub const HTTPSProxy: Self = Self(0x68747378);
    #[doc(alias = "kSecProtocolTypeFTPProxy")]
    pub const FTPProxy: Self = Self(0x66747078);
    #[doc(alias = "kSecProtocolTypeCIFS")]
    pub const CIFS: Self = Self(0x63696673);
    #[doc(alias = "kSecProtocolTypeSMB")]
    pub const SMB: Self = Self(0x736d6220);
    #[doc(alias = "kSecProtocolTypeRTSP")]
    pub const RTSP: Self = Self(0x72747370);
    #[doc(alias = "kSecProtocolTypeRTSPProxy")]
    pub const RTSPProxy: Self = Self(0x72747378);
    #[doc(alias = "kSecProtocolTypeDAAP")]
    pub const DAAP: Self = Self(0x64616170);
    #[doc(alias = "kSecProtocolTypeEPPC")]
    pub const EPPC: Self = Self(0x65707063);
    #[doc(alias = "kSecProtocolTypeIPP")]
    pub const IPP: Self = Self(0x69707020);
    #[doc(alias = "kSecProtocolTypeNNTPS")]
    pub const NNTPS: Self = Self(0x6e747073);
    #[doc(alias = "kSecProtocolTypeLDAPS")]
    pub const LDAPS: Self = Self(0x6c647073);
    #[doc(alias = "kSecProtocolTypeTelnetS")]
    pub const TelnetS: Self = Self(0x74656c73);
    #[doc(alias = "kSecProtocolTypeIMAPS")]
    pub const IMAPS: Self = Self(0x696d7073);
    #[doc(alias = "kSecProtocolTypeIRCS")]
    pub const IRCS: Self = Self(0x69726373);
    #[doc(alias = "kSecProtocolTypePOP3S")]
    pub const POP3S: Self = Self(0x706f7073);
    #[doc(alias = "kSecProtocolTypeCVSpserver")]
    pub const CVSpserver: Self = Self(0x63767370);
    #[doc(alias = "kSecProtocolTypeSVN")]
    pub const SVN: Self = Self(0x73766e20);
    #[doc(alias = "kSecProtocolTypeAny")]
    pub const Any: Self = Self(0);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecProtocolType {
    const ENCODING: Encoding = FourCharCode::ENCODING;
}

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

/// Defines the keychain-related event.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/seckeychainevent?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SecKeychainEvent(pub u32);
impl SecKeychainEvent {
    #[doc(alias = "kSecLockEvent")]
    pub const LockEvent: Self = Self(1);
    #[doc(alias = "kSecUnlockEvent")]
    pub const UnlockEvent: Self = Self(2);
    #[doc(alias = "kSecAddEvent")]
    pub const AddEvent: Self = Self(3);
    #[doc(alias = "kSecDeleteEvent")]
    pub const DeleteEvent: Self = Self(4);
    #[doc(alias = "kSecUpdateEvent")]
    pub const UpdateEvent: Self = Self(5);
    #[doc(alias = "kSecPasswordChangedEvent")]
    pub const PasswordChangedEvent: Self = Self(6);
    #[doc(alias = "kSecDefaultChangedEvent")]
    pub const DefaultChangedEvent: Self = Self(9);
    #[doc(alias = "kSecDataAccessEvent")]
    #[deprecated = "Read events are no longer posted"]
    pub const DataAccessEvent: Self = Self(10);
    #[doc(alias = "kSecKeychainListChangedEvent")]
    pub const KeychainListChangedEvent: Self = Self(11);
    #[doc(alias = "kSecTrustSettingsChangedEvent")]
    pub const TrustSettingsChangedEvent: Self = Self(12);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecKeychainEvent {
    const ENCODING: Encoding = u32::ENCODING;
}

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

/// Defines keychain event constants
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/seckeychaineventmask?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SecKeychainEventMask(pub u32);
bitflags::bitflags! {
    impl SecKeychainEventMask: u32 {
        #[doc(alias = "kSecLockEventMask")]
        const LockEventMask = 1<<SecKeychainEvent::LockEvent.0;
        #[doc(alias = "kSecUnlockEventMask")]
        const UnlockEventMask = 1<<SecKeychainEvent::UnlockEvent.0;
        #[doc(alias = "kSecAddEventMask")]
        const AddEventMask = 1<<SecKeychainEvent::AddEvent.0;
        #[doc(alias = "kSecDeleteEventMask")]
        const DeleteEventMask = 1<<SecKeychainEvent::DeleteEvent.0;
        #[doc(alias = "kSecUpdateEventMask")]
        const UpdateEventMask = 1<<SecKeychainEvent::UpdateEvent.0;
        #[doc(alias = "kSecPasswordChangedEventMask")]
        const PasswordChangedEventMask = 1<<SecKeychainEvent::PasswordChangedEvent.0;
        #[doc(alias = "kSecDefaultChangedEventMask")]
        const DefaultChangedEventMask = 1<<SecKeychainEvent::DefaultChangedEvent.0;
        #[doc(alias = "kSecDataAccessEventMask")]
#[deprecated = "Read events are no longer posted"]
        const DataAccessEventMask = 1<<SecKeychainEvent::DataAccessEvent.0;
        #[doc(alias = "kSecKeychainListChangedMask")]
        const KeychainListChangedMask = 1<<SecKeychainEvent::KeychainListChangedEvent.0;
        #[doc(alias = "kSecTrustSettingsChangedEventMask")]
        const TrustSettingsChangedEventMask = 1<<SecKeychainEvent::TrustSettingsChangedEvent.0;
        #[doc(alias = "kSecEveryEventMask")]
        const EveryEventMask = 0xffffffff;
    }
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecKeychainEventMask {
    const ENCODING: Encoding = u32::ENCODING;
}

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

/// Contains information about a keychain event.
/// Field: version The version of this structure.
/// Field: item A reference to the keychain item associated with this event, if any. Note that some events do not involve a particular keychain item.
/// Field: keychain A reference to the keychain in which the event occurred.
/// Field: pid The id of the process that generated this event.
///
/// The SecKeychainCallbackInfo type represents a structure that contains information about the keychain event for which your application is being notified. For information on how to write a keychain event callback function, see SecKeychainCallback.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/seckeychaincallbackinfo?language=objc)
#[cfg(all(feature = "SecBase", feature = "libc"))]
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SecKeychainCallbackInfo {
    pub version: u32,
    pub item: NonNull<SecKeychainItem>,
    pub keychain: NonNull<SecKeychain>,
    pub pid: libc::pid_t,
}

#[cfg(all(feature = "SecBase", feature = "libc", feature = "objc2"))]
unsafe impl Encode for SecKeychainCallbackInfo {
    const ENCODING: Encoding = Encoding::Struct(
        "SecKeychainCallbackInfo",
        &[
            <u32>::ENCODING,
            <NonNull<SecKeychainItem>>::ENCODING,
            <NonNull<SecKeychain>>::ENCODING,
            <libc::pid_t>::ENCODING,
        ],
    );
}

#[cfg(all(feature = "SecBase", feature = "libc", feature = "objc2"))]
unsafe impl RefEncode for SecKeychainCallbackInfo {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "SecBase")]
unsafe impl ConcreteType for SecKeychain {
    /// Returns the type identifier of SecKeychain instances.
    ///
    /// Returns: The CFTypeID of SecKeychain instances.
    #[doc(alias = "SecKeychainGetTypeID")]
    #[inline]
    fn type_id() -> CFTypeID {
        extern "C-unwind" {
            fn SecKeychainGetTypeID() -> CFTypeID;
        }
        unsafe { SecKeychainGetTypeID() }
    }
}

#[cfg(feature = "SecBase")]
impl SecKeychain {
    /// Determines the version of the Keychain Manager installed on the user�s system.
    ///
    /// Parameter `returnVers`: On return, a pointer to the version number of the Keychain Manager installed on the current system.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `return_vers` must be a valid pointer.
    #[doc(alias = "SecKeychainGetVersion")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn version(return_vers: NonNull<u32>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetVersion(return_vers: NonNull<u32>) -> OSStatus;
        }
        unsafe { SecKeychainGetVersion(return_vers) }
    }

    /// Create a SecKeychainRef for a keychain at pathName.  This keychain might
    /// not currently exist, use SecKeychainGetStatus if you want to confirm the existence
    /// of this keychain.
    ///
    /// Parameter `pathName`: The POSIX path to a keychain.
    ///
    /// Parameter `keychain`: On return, a pointer to the keychain reference. The memory that keychain occupies must be released by calling CFRelease when finished with it.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if the keychain parameter is invalid (NULL).
    ///
    /// # Safety
    ///
    /// - `path_name` must be a valid pointer.
    /// - `keychain` must be a valid pointer.
    #[doc(alias = "SecKeychainOpen")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn open(
        path_name: NonNull<c_char>,
        keychain: NonNull<*mut SecKeychain>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainOpen(
                path_name: NonNull<c_char>,
                keychain: NonNull<*mut SecKeychain>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainOpen(path_name, keychain) }
    }

    /// Creates a new keychain.
    ///
    /// Parameter `pathName`: The POSIX path to a keychain file.
    ///
    /// Parameter `passwordLength`: An unsigned 32-bit integer representing the length of the password buffer.
    ///
    /// Parameter `password`: A pointer to the buffer containing the password. The password must be in canonical UTF8 encoding.
    ///
    /// Parameter `promptUser`: A boolean representing whether to display a password dialog to the user.
    ///
    /// Parameter `initialAccess`: An access reference.
    ///
    /// Parameter `keychain`: On return, a pointer to a keychain reference. The memory that keychain occupies must be released by calling CFRelease when finished with it.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if the keychain parameter is invalid (NULL).
    ///
    /// # Safety
    ///
    /// - `path_name` must be a valid pointer.
    /// - `password` must be a valid pointer or null.
    /// - `keychain` must be a valid pointer.
    #[doc(alias = "SecKeychainCreate")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn create(
        path_name: NonNull<c_char>,
        password_length: u32,
        password: *const c_void,
        prompt_user: bool,
        initial_access: Option<&SecAccess>,
        keychain: NonNull<*mut SecKeychain>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCreate(
                path_name: NonNull<c_char>,
                password_length: u32,
                password: *const c_void,
                prompt_user: Boolean,
                initial_access: Option<&SecAccess>,
                keychain: NonNull<*mut SecKeychain>,
            ) -> OSStatus;
        }
        unsafe {
            SecKeychainCreate(
                path_name,
                password_length,
                password,
                prompt_user as _,
                initial_access,
                keychain,
            )
        }
    }

    /// Removes one or more keychains from the current keychain searchlist, and deletes the keychain storage (if the keychains are file-based).
    ///
    /// Parameter `keychainOrArray`: A single keychain reference or a reference to an array of keychains to delete. IMPORTANT: SecKeychainDelete does not dispose the memory occupied by keychain references; use the CFRelease function when you are completely finished with a keychain.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecInvalidKeychain (-25295) may be returned if the keychain parameter is invalid (NULL).
    #[doc(alias = "SecKeychainDelete")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn delete(keychain_or_array: Option<&SecKeychain>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainDelete(keychain_or_array: Option<&SecKeychain>) -> OSStatus;
        }
        unsafe { SecKeychainDelete(keychain_or_array) }
    }

    /// Changes the settings of a keychain.
    ///
    /// Parameter `keychain`: A reference to a keychain.
    ///
    /// Parameter `newSettings`: A pointer to the new keychain settings.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `new_settings` must be a valid pointer.
    #[doc(alias = "SecKeychainSetSettings")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_settings(
        keychain: Option<&SecKeychain>,
        new_settings: NonNull<SecKeychainSettings>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetSettings(
                keychain: Option<&SecKeychain>,
                new_settings: NonNull<SecKeychainSettings>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainSetSettings(keychain, new_settings) }
    }

    /// Copy the keychain settings.
    ///
    /// Parameter `keychain`: A reference to the keychain from which to copy its settings.
    ///
    /// Parameter `outSettings`: A pointer to a keychain settings structure. Since this structure is versioned, you must preallocate it and fill in the version of the structure.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `out_settings` must be a valid pointer.
    #[doc(alias = "SecKeychainCopySettings")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_settings(
        keychain: Option<&SecKeychain>,
        out_settings: NonNull<SecKeychainSettings>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopySettings(
                keychain: Option<&SecKeychain>,
                out_settings: NonNull<SecKeychainSettings>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainCopySettings(keychain, out_settings) }
    }

    /// Unlocks the specified keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain to unlock. Pass NULL to specify the default keychain. If you pass NULL and the default keychain is currently locked, the keychain will appear as the default choice. If you pass a locked keychain, SecKeychainUnlock will use the password provided to unlock it. If the default keychain is currently unlocked, SecKeychainUnlock returns errSecSuccess.
    ///
    /// Parameter `passwordLength`: An unsigned 32-bit integer representing the length of the password buffer.
    ///
    /// Parameter `password`: A buffer containing the password for the keychain. Pass NULL if the user password is unknown. In this case, SecKeychainUnlock displays the Unlock Keychain dialog box, and the authentication user interface associated with the keychain about to be unlocked.
    ///
    /// Parameter `usePassword`: A boolean indicating whether the password parameter is used.  You should pass TRUE if it is used or FALSE if it is ignored.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// In most cases, your application does not need to call the SecKeychainUnlock function directly, since most Keychain Manager functions that require an unlocked keychain call SecKeychainUnlock automatically. If your application needs to verify that a keychain is unlocked, call the function SecKeychainGetStatus.
    ///
    /// # Safety
    ///
    /// `password` must be a valid pointer or null.
    #[doc(alias = "SecKeychainUnlock")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn unlock(
        keychain: Option<&SecKeychain>,
        password_length: u32,
        password: *const c_void,
        use_password: bool,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainUnlock(
                keychain: Option<&SecKeychain>,
                password_length: u32,
                password: *const c_void,
                use_password: Boolean,
            ) -> OSStatus;
        }
        unsafe { SecKeychainUnlock(keychain, password_length, password, use_password as _) }
    }

    /// Locks the specified keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain to lock.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    #[doc(alias = "SecKeychainLock")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn lock(keychain: Option<&SecKeychain>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainLock(keychain: Option<&SecKeychain>) -> OSStatus;
        }
        unsafe { SecKeychainLock(keychain) }
    }

    /// Locks all keychains belonging to the current user.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    #[doc(alias = "SecKeychainLockAll")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn lock_all() -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainLockAll() -> OSStatus;
        }
        unsafe { SecKeychainLockAll() }
    }

    /// Retrieves a reference to the default keychain.
    ///
    /// Parameter `keychain`: On return, a pointer to the default keychain reference.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `keychain` must be a valid pointer.
    #[doc(alias = "SecKeychainCopyDefault")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_default(keychain: NonNull<*mut SecKeychain>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopyDefault(keychain: NonNull<*mut SecKeychain>) -> OSStatus;
        }
        unsafe { SecKeychainCopyDefault(keychain) }
    }

    /// Sets the default keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain to set as default.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if the keychain parameter is invalid (NULL).
    #[doc(alias = "SecKeychainSetDefault")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_default(keychain: Option<&SecKeychain>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetDefault(keychain: Option<&SecKeychain>) -> OSStatus;
        }
        unsafe { SecKeychainSetDefault(keychain) }
    }

    /// Retrieves a keychain search list.
    ///
    /// Parameter `searchList`: The returned list of keychains to search. When finished with the array, you must call CFRelease() to release the memory.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if the keychain list is not specified (NULL).
    ///
    /// # Safety
    ///
    /// `search_list` must be a valid pointer.
    #[doc(alias = "SecKeychainCopySearchList")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_search_list(search_list: NonNull<*const CFArray>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopySearchList(search_list: NonNull<*const CFArray>) -> OSStatus;
        }
        unsafe { SecKeychainCopySearchList(search_list) }
    }

    /// Specifies the list of keychains to use in a keychain search list.
    ///
    /// Parameter `searchList`: The list of keychains to use in a search list when the SecKeychainCopySearchList function is called. An empty array clears the search list.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if the keychain list is not specified (NULL).
    ///
    /// # Safety
    ///
    /// `search_list` generic must be of the correct type.
    #[doc(alias = "SecKeychainSetSearchList")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_search_list(search_list: &CFArray) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetSearchList(search_list: &CFArray) -> OSStatus;
        }
        unsafe { SecKeychainSetSearchList(search_list) }
    }
}

/// [Apple's documentation](https://developer.apple.com/documentation/security/secpreferencesdomain?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SecPreferencesDomain(pub c_int);
impl SecPreferencesDomain {
    #[doc(alias = "kSecPreferencesDomainUser")]
    pub const User: Self = Self(0);
    #[doc(alias = "kSecPreferencesDomainSystem")]
    pub const System: Self = Self(1);
    #[doc(alias = "kSecPreferencesDomainCommon")]
    pub const Common: Self = Self(2);
    #[doc(alias = "kSecPreferencesDomainDynamic")]
    pub const Dynamic: Self = Self(3);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for SecPreferencesDomain {
    const ENCODING: Encoding = c_int::ENCODING;
}

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

#[cfg(feature = "SecBase")]
impl SecKeychain {
    /// # Safety
    ///
    /// `keychain` must be a valid pointer.
    #[doc(alias = "SecKeychainCopyDomainDefault")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_domain_default(
        domain: SecPreferencesDomain,
        keychain: NonNull<*mut SecKeychain>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopyDomainDefault(
                domain: SecPreferencesDomain,
                keychain: NonNull<*mut SecKeychain>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainCopyDomainDefault(domain, keychain) }
    }

    #[doc(alias = "SecKeychainSetDomainDefault")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_domain_default(
        domain: SecPreferencesDomain,
        keychain: Option<&SecKeychain>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetDomainDefault(
                domain: SecPreferencesDomain,
                keychain: Option<&SecKeychain>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainSetDomainDefault(domain, keychain) }
    }

    /// # Safety
    ///
    /// `search_list` must be a valid pointer.
    #[doc(alias = "SecKeychainCopyDomainSearchList")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_domain_search_list(
        domain: SecPreferencesDomain,
        search_list: NonNull<*const CFArray>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopyDomainSearchList(
                domain: SecPreferencesDomain,
                search_list: NonNull<*const CFArray>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainCopyDomainSearchList(domain, search_list) }
    }

    /// # Safety
    ///
    /// `search_list` generic must be of the correct type.
    #[doc(alias = "SecKeychainSetDomainSearchList")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_domain_search_list(
        domain: SecPreferencesDomain,
        search_list: &CFArray,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetDomainSearchList(
                domain: SecPreferencesDomain,
                search_list: &CFArray,
            ) -> OSStatus;
        }
        unsafe { SecKeychainSetDomainSearchList(domain, search_list) }
    }

    #[doc(alias = "SecKeychainSetPreferenceDomain")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_preference_domain(domain: SecPreferencesDomain) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetPreferenceDomain(domain: SecPreferencesDomain) -> OSStatus;
        }
        unsafe { SecKeychainSetPreferenceDomain(domain) }
    }

    /// # Safety
    ///
    /// `domain` must be a valid pointer.
    #[doc(alias = "SecKeychainGetPreferenceDomain")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn preference_domain(domain: NonNull<SecPreferencesDomain>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetPreferenceDomain(domain: NonNull<SecPreferencesDomain>) -> OSStatus;
        }
        unsafe { SecKeychainGetPreferenceDomain(domain) }
    }

    /// Retrieves status information for the specified keychain.
    ///
    /// Parameter `keychain`: A keychain reference. Pass NULL to specify the default keychain.
    ///
    /// Parameter `keychainStatus`: On return, a pointer to the status of the specified keychain.  See KeychainStatus for valid status constants.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `keychain_status` must be a valid pointer.
    #[doc(alias = "SecKeychainGetStatus")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn status(
        keychain: Option<&SecKeychain>,
        keychain_status: NonNull<SecKeychainStatus>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetStatus(
                keychain: Option<&SecKeychain>,
                keychain_status: NonNull<SecKeychainStatus>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainGetStatus(keychain, keychain_status) }
    }

    /// Get the path of the specified keychain.
    ///
    /// Parameter `keychain`: A reference to a keychain.
    ///
    /// Parameter `ioPathLength`: On input, a pointer to the size of the buffer pointed to by pathName. On return, the size of the buffer without the zero termination.
    ///
    /// Parameter `pathName`: On return, the POSIX path to the keychain.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// - `io_path_length` must be a valid pointer.
    /// - `path_name` must be a valid pointer.
    #[doc(alias = "SecKeychainGetPath")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn path(
        keychain: Option<&SecKeychain>,
        io_path_length: NonNull<u32>,
        path_name: NonNull<c_char>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetPath(
                keychain: Option<&SecKeychain>,
                io_path_length: NonNull<u32>,
                path_name: NonNull<c_char>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainGetPath(keychain, io_path_length, path_name) }
    }

    /// Obtains tags for all possible attributes for a given item class.
    ///
    /// Parameter `keychain`: A keychain reference.
    ///
    /// Parameter `itemID`: The relation identifier of the item tags (an itemID is a CSSM_DB_RECORDTYPE defined in cssmapple.h).
    ///
    /// Parameter `info`: On return, a pointer to the keychain attribute information. User should call the SecKeychainFreeAttributeInfo function to release the structure when done with it.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if not enough valid parameters were supplied (NULL).
    ///
    /// Warning, this call returns more attributes than are support by the old style Keychain API and passing them into older calls will yield an invalid attribute error. The recommended call to retrieve the attribute values is the SecKeychainItemCopyAttributesAndData function.
    ///
    /// # Safety
    ///
    /// `info` must be a valid pointer.
    #[doc(alias = "SecKeychainAttributeInfoForItemID")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn attribute_info_for_item_id(
        keychain: Option<&SecKeychain>,
        item_id: u32,
        info: NonNull<*mut SecKeychainAttributeInfo>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainAttributeInfoForItemID(
                keychain: Option<&SecKeychain>,
                item_id: u32,
                info: NonNull<*mut SecKeychainAttributeInfo>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainAttributeInfoForItemID(keychain, item_id, info) }
    }

    /// Releases the memory acquired by calling the SecKeychainAttributeInfoForItemID function.
    ///
    /// Parameter `info`: A pointer to the keychain attribute information to release.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h). In addition, errSecParam (-50) may be returned if not enough valid parameters were supplied (NULL).
    ///
    /// # Safety
    ///
    /// `info` must be a valid pointer.
    #[doc(alias = "SecKeychainFreeAttributeInfo")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn free_attribute_info(info: NonNull<SecKeychainAttributeInfo>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainFreeAttributeInfo(info: NonNull<SecKeychainAttributeInfo>) -> OSStatus;
        }
        unsafe { SecKeychainFreeAttributeInfo(info) }
    }
}

/// Defines a pointer to a customized callback function.  You supply the customized callback function to do a callback tailored to your application's needs.
///
/// Parameter `keychainEvent`: The keychain event that your application wishes to be notified of. See SecKeychainEvent for a description of possible values. The type of event that can trigger your callback depends on the bit mask you passed in the eventMask parameter of the function SecKeychainAddCallback. For more information, see the discussion.
///
/// Parameter `info`: A pointer to a structure of type SecKeychainCallbackInfo. On return, the structure contains information about the keychain event that occurred. The Keychain Manager passes this information to your callback function via the info parameter.
///
/// Parameter `context`: A pointer to application-defined storage that your application previously passed to the function SecKeychainAddCallback. You can use this value to perform operations like track which instance of a function is operating.
///
/// Returns: A result code.  See "Security Error Codes" (SecBase.h).
///
/// If you name your function MyKeychainEventCallback, you would declare it like this:
/// OSStatus MyKeychainEventCallback (
/// SecKeychainEvent keychainEvent,
/// SecKeychainCallbackInfo *info,
/// void *context);
///
/// To add your callback function, use the SecKeychainAddCallback function.  To remove your callback function, use the SecKeychainRemoveCallback function.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/security/seckeychaincallback?language=objc)
#[deprecated = "SecKeychain is deprecated"]
#[cfg(all(feature = "SecBase", feature = "libc"))]
pub type SecKeychainCallback = Option<
    unsafe extern "C-unwind" fn(
        SecKeychainEvent,
        NonNull<SecKeychainCallbackInfo>,
        *mut c_void,
    ) -> OSStatus,
>;

#[cfg(feature = "SecBase")]
impl SecKeychain {
    /// Registers your keychain event callback function
    ///
    /// Parameter `callbackFunction`: A pointer to your keychain event callback function, described in SecKeychainCallback. You indicate the type of keychain events you want to receive by passing a bit mask of the desired events in the eventMask parameter.
    ///
    /// Parameter `eventMask`: A bit mask indicating the keychain events that your application wishes to be notified of. See SecKeychainEventMask for a description of this bit mask. The Keychain Manager tests this mask to determine the keychain events that you wish to receive, and passes these events in the keychainEvent parameter of your callback function. See SecKeychainEvent for a description of these events.
    ///
    /// Parameter `userContext`: A pointer to application-defined storage that will be passed to your callback function. Your application can use this to associate any particular call of SecKeychainAddCallback with any particular call of your keychain event callback function.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// - `callback_function` must be implemented correctly.
    /// - `user_context` must be a valid pointer or null.
    #[doc(alias = "SecKeychainAddCallback")]
    #[cfg(all(feature = "SecBase", feature = "libc"))]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn add_callback(
        callback_function: SecKeychainCallback,
        event_mask: SecKeychainEventMask,
        user_context: *mut c_void,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainAddCallback(
                callback_function: SecKeychainCallback,
                event_mask: SecKeychainEventMask,
                user_context: *mut c_void,
            ) -> OSStatus;
        }
        unsafe { SecKeychainAddCallback(callback_function, event_mask, user_context) }
    }

    /// Unregisters your keychain event callback function. Once removed, keychain events won't be sent to the owner of the callback.
    ///
    /// Parameter `callbackFunction`: The callback function pointer to remove
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `callback_function` must be implemented correctly.
    #[doc(alias = "SecKeychainRemoveCallback")]
    #[cfg(all(feature = "SecBase", feature = "libc"))]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn remove_callback(callback_function: SecKeychainCallback) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainRemoveCallback(callback_function: SecKeychainCallback) -> OSStatus;
        }
        unsafe { SecKeychainRemoveCallback(callback_function) }
    }

    /// Adds an Internet password to the specified keychain.
    ///
    /// Parameter `keychain`: A reference to a keychain in which to store an Internet password. Pass NULL to specify the user's default keychain.
    ///
    /// Parameter `serverNameLength`: The length of the buffer pointed to by serverName.
    ///
    /// Parameter `serverName`: A pointer to a string containing the server name associated with this password.
    ///
    /// Parameter `securityDomainLength`: The length of the buffer pointed to by securityDomain.
    ///
    /// Parameter `securityDomain`: A pointer to a string containing the security domain associated with this password, or NULL if there is no relevant security domain.
    ///
    /// Parameter `accountNameLength`: The length of the buffer pointed to by accountName.
    ///
    /// Parameter `accountName`: A pointer to a string containing the account name associated with this password.
    ///
    /// Parameter `pathLength`: The length of the buffer pointed to by path.
    ///
    /// Parameter `path`: A pointer to a string containing the path associated with this password, or NULL if there is no relevant path string.
    ///
    /// Parameter `port`: The TCP/IP port number. If no specific port number is associated with this item, pass 0.
    ///
    /// Parameter `protocol`: The protocol associated with this password. See SecProtocolType for a description of possible values.
    ///
    /// Parameter `authenticationType`: The authentication scheme used. See SecAuthenticationType for a description of possible values. Pass the constant kSecAuthenticationTypeDefault to specify the default authentication scheme.
    ///
    /// Parameter `passwordLength`: The length of the buffer pointed to by passwordData.
    ///
    /// Parameter `passwordData`: A pointer to a buffer containing the password data to be stored in the keychain.
    ///
    /// Parameter `itemRef`: On return, a reference to the new keychain item.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// The SecKeychainAddInternetPassword function adds a new Internet server password to the specified keychain. Required parameters to identify the password are serverName and accountName (you cannot pass NULL for both parameters). In addition, some protocols may require an optional securityDomain when authentication is requested. SecKeychainAddInternetPassword optionally returns a reference to the newly added item.
    ///
    /// # Safety
    ///
    /// - `server_name` must be a valid pointer or null.
    /// - `security_domain` must be a valid pointer or null.
    /// - `account_name` must be a valid pointer or null.
    /// - `path` must be a valid pointer or null.
    /// - `password_data` must be a valid pointer.
    /// - `item_ref` must be a valid pointer or null.
    #[doc(alias = "SecKeychainAddInternetPassword")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn add_internet_password(
        keychain: Option<&SecKeychain>,
        server_name_length: u32,
        server_name: *const c_char,
        security_domain_length: u32,
        security_domain: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        path_length: u32,
        path: *const c_char,
        port: u16,
        protocol: SecProtocolType,
        authentication_type: SecAuthenticationType,
        password_length: u32,
        password_data: NonNull<c_void>,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainAddInternetPassword(
                keychain: Option<&SecKeychain>,
                server_name_length: u32,
                server_name: *const c_char,
                security_domain_length: u32,
                security_domain: *const c_char,
                account_name_length: u32,
                account_name: *const c_char,
                path_length: u32,
                path: *const c_char,
                port: u16,
                protocol: SecProtocolType,
                authentication_type: SecAuthenticationType,
                password_length: u32,
                password_data: NonNull<c_void>,
                item_ref: *mut *mut SecKeychainItem,
            ) -> OSStatus;
        }
        unsafe {
            SecKeychainAddInternetPassword(
                keychain,
                server_name_length,
                server_name,
                security_domain_length,
                security_domain,
                account_name_length,
                account_name,
                path_length,
                path,
                port,
                protocol,
                authentication_type,
                password_length,
                password_data,
                item_ref,
            )
        }
    }

    /// Finds an Internet password based on the attributes passed.
    ///
    /// Parameter `keychainOrArray`: A reference to an array of keychains to search, a single keychain, or NULL to search the user's default keychain search list.
    ///
    /// Parameter `serverNameLength`: The length of the buffer pointed to by serverName.
    ///
    /// Parameter `serverName`: A pointer to a string containing the server name.
    ///
    /// Parameter `securityDomainLength`: The length of the buffer pointed to by securityDomain.
    ///
    /// Parameter `securityDomain`: A pointer to a string containing the security domain. This parameter is optional, as not all protocols will require it.
    ///
    /// Parameter `accountNameLength`: The length of the buffer pointed to by accountName.
    ///
    /// Parameter `accountName`: A pointer to a string containing the account name.
    ///
    /// Parameter `pathLength`: The length of the buffer pointed to by path.
    ///
    /// Parameter `path`: A pointer to a string containing the path.
    ///
    /// Parameter `port`: The TCP/IP port number. Pass 0 to ignore the port number.
    ///
    /// Parameter `protocol`: The protocol associated with this password. See SecProtocolType for a description of possible values.
    ///
    /// Parameter `authenticationType`: The authentication scheme used. See SecAuthenticationType for a description of possible values. Pass the constant kSecAuthenticationTypeDefault to specify the default authentication scheme.
    ///
    /// Parameter `passwordLength`: On return, the length of the buffer pointed to by passwordData.
    ///
    /// Parameter `passwordData`: On return, a pointer to a data buffer containing the password. Your application must call SecKeychainItemFreeContent(NULL, passwordData) to release this data buffer when it is no longer needed. Pass NULL if you are not interested in retrieving the password data at this time, but simply want to find the item reference.
    ///
    /// Parameter `itemRef`: On return, a reference to the keychain item which was found.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// The SecKeychainFindInternetPassword function finds the first Internet password item which matches the attributes you provide. Most attributes are optional; you should pass only as many as you need to narrow the search sufficiently for your application's intended use. SecKeychainFindInternetPassword optionally returns a reference to the found item.
    ///
    /// # Safety
    ///
    /// - `keychain_or_array` should be of the correct type.
    /// - `server_name` must be a valid pointer or null.
    /// - `security_domain` must be a valid pointer or null.
    /// - `account_name` must be a valid pointer or null.
    /// - `path` must be a valid pointer or null.
    /// - `password_length` must be a valid pointer or null.
    /// - `password_data` must be a valid pointer or null.
    /// - `item_ref` must be a valid pointer or null.
    #[doc(alias = "SecKeychainFindInternetPassword")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn find_internet_password(
        keychain_or_array: Option<&CFType>,
        server_name_length: u32,
        server_name: *const c_char,
        security_domain_length: u32,
        security_domain: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        path_length: u32,
        path: *const c_char,
        port: u16,
        protocol: SecProtocolType,
        authentication_type: SecAuthenticationType,
        password_length: *mut u32,
        password_data: *mut *mut c_void,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainFindInternetPassword(
                keychain_or_array: Option<&CFType>,
                server_name_length: u32,
                server_name: *const c_char,
                security_domain_length: u32,
                security_domain: *const c_char,
                account_name_length: u32,
                account_name: *const c_char,
                path_length: u32,
                path: *const c_char,
                port: u16,
                protocol: SecProtocolType,
                authentication_type: SecAuthenticationType,
                password_length: *mut u32,
                password_data: *mut *mut c_void,
                item_ref: *mut *mut SecKeychainItem,
            ) -> OSStatus;
        }
        unsafe {
            SecKeychainFindInternetPassword(
                keychain_or_array,
                server_name_length,
                server_name,
                security_domain_length,
                security_domain,
                account_name_length,
                account_name,
                path_length,
                path,
                port,
                protocol,
                authentication_type,
                password_length,
                password_data,
                item_ref,
            )
        }
    }

    /// Adds a generic password to the specified keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain in which to store a generic password. Pass NULL to specify the user's default keychain.
    ///
    /// Parameter `serviceNameLength`: The length of the buffer pointed to by serviceName.
    ///
    /// Parameter `serviceName`: A pointer to a string containing the service name associated with this password.
    ///
    /// Parameter `accountNameLength`: The length of the buffer pointed to by accountName.
    ///
    /// Parameter `accountName`: A pointer to a string containing the account name associated with this password.
    ///
    /// Parameter `passwordLength`: The length of the buffer pointed to by passwordData.
    ///
    /// Parameter `passwordData`: A pointer to a buffer containing the password data to be stored in the keychain.
    ///
    /// Parameter `itemRef`: On return, a reference to the new keychain item.
    ///
    /// Returns: A result code. See "Security Error Codes" (SecBase.h).
    ///
    /// The SecKeychainAddGenericPassword function adds a new generic password to the default keychain. Required parameters to identify the password are serviceName and accountName, which are application-defined strings. SecKeychainAddGenericPassword optionally returns a reference to the newly added item.
    ///
    /// # Safety
    ///
    /// - `service_name` must be a valid pointer or null.
    /// - `account_name` must be a valid pointer or null.
    /// - `password_data` must be a valid pointer.
    /// - `item_ref` must be a valid pointer or null.
    #[doc(alias = "SecKeychainAddGenericPassword")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn add_generic_password(
        keychain: Option<&SecKeychain>,
        service_name_length: u32,
        service_name: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        password_length: u32,
        password_data: NonNull<c_void>,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainAddGenericPassword(
                keychain: Option<&SecKeychain>,
                service_name_length: u32,
                service_name: *const c_char,
                account_name_length: u32,
                account_name: *const c_char,
                password_length: u32,
                password_data: NonNull<c_void>,
                item_ref: *mut *mut SecKeychainItem,
            ) -> OSStatus;
        }
        unsafe {
            SecKeychainAddGenericPassword(
                keychain,
                service_name_length,
                service_name,
                account_name_length,
                account_name,
                password_length,
                password_data,
                item_ref,
            )
        }
    }

    /// Find a generic password based on the attributes passed.
    ///
    /// Parameter `keychainOrArray`: A reference to an array of keychains to search, a single keychain, or NULL to search the user's default keychain search list.
    ///
    /// Parameter `serviceNameLength`: The length of the buffer pointed to by serviceName.
    ///
    /// Parameter `serviceName`: A pointer to a string containing the service name.
    ///
    /// Parameter `accountNameLength`: The length of the buffer pointed to by accountName.
    ///
    /// Parameter `accountName`: A pointer to a string containing the account name.
    ///
    /// Parameter `passwordLength`: On return, the length of the buffer pointed to by passwordData.
    ///
    /// Parameter `passwordData`: On return, a pointer to a data buffer containing the password. Your application must call SecKeychainItemFreeContent(NULL, passwordData) to release this data buffer when it is no longer needed. Pass NULL if you are not interested in retrieving the password data at this time, but simply want to find the item reference.
    ///
    /// Parameter `itemRef`: On return, a reference to the keychain item which was found.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// The SecKeychainFindGenericPassword function finds the first generic password item which matches the attributes you provide. Most attributes are optional; you should pass only as many as you need to narrow the search sufficiently for your application's intended use. SecKeychainFindGenericPassword optionally returns a reference to the found item.
    ///
    /// # Safety
    ///
    /// - `keychain_or_array` should be of the correct type.
    /// - `service_name` must be a valid pointer or null.
    /// - `account_name` must be a valid pointer or null.
    /// - `password_length` must be a valid pointer or null.
    /// - `password_data` must be a valid pointer or null.
    /// - `item_ref` must be a valid pointer or null.
    #[doc(alias = "SecKeychainFindGenericPassword")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn find_generic_password(
        keychain_or_array: Option<&CFType>,
        service_name_length: u32,
        service_name: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        password_length: *mut u32,
        password_data: *mut *mut c_void,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainFindGenericPassword(
                keychain_or_array: Option<&CFType>,
                service_name_length: u32,
                service_name: *const c_char,
                account_name_length: u32,
                account_name: *const c_char,
                password_length: *mut u32,
                password_data: *mut *mut c_void,
                item_ref: *mut *mut SecKeychainItem,
            ) -> OSStatus;
        }
        unsafe {
            SecKeychainFindGenericPassword(
                keychain_or_array,
                service_name_length,
                service_name,
                account_name_length,
                account_name,
                password_length,
                password_data,
                item_ref,
            )
        }
    }

    /// Turns on or off any optional user interaction
    ///
    /// Parameter `state`: A boolean representing the state of user interaction.  You should pass TRUE to allow user interaction, and FALSE to disallow user interaction
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    #[doc(alias = "SecKeychainSetUserInteractionAllowed")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_user_interaction_allowed(state: bool) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetUserInteractionAllowed(state: Boolean) -> OSStatus;
        }
        unsafe { SecKeychainSetUserInteractionAllowed(state as _) }
    }

    /// Retrieves the current state of user interaction.
    ///
    /// Parameter `state`: On return, a pointer to the current state of user interaction.  If this is TRUE then user interaction is allowed, if it is FALSE, then user interaction is not allowed.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `state` must be a valid pointer.
    #[doc(alias = "SecKeychainGetUserInteractionAllowed")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn user_interaction_allowed(state: NonNull<Boolean>) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetUserInteractionAllowed(state: NonNull<Boolean>) -> OSStatus;
        }
        unsafe { SecKeychainGetUserInteractionAllowed(state) }
    }

    /// Returns the CSSM_CSP_HANDLE attachment for the given keychain reference. The handle is valid until the keychain reference is released.
    ///
    /// Parameter `keychain`: A keychain reference.
    ///
    /// Parameter `cspHandle`: On return, a pointer to the CSSM_CSP_HANDLE for the given keychain.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// This API is deprecated for 10.7. It should nho longer be needed.
    ///
    /// # Safety
    ///
    /// `csp_handle` must be a valid pointer.
    #[doc(alias = "SecKeychainGetCSPHandle")]
    #[cfg(all(feature = "SecBase", feature = "cssmconfig", feature = "cssmtype"))]
    #[deprecated]
    #[inline]
    pub unsafe fn csp_handle(
        keychain: Option<&SecKeychain>,
        csp_handle: NonNull<CSSM_CSP_HANDLE>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetCSPHandle(
                keychain: Option<&SecKeychain>,
                csp_handle: NonNull<CSSM_CSP_HANDLE>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainGetCSPHandle(keychain, csp_handle) }
    }

    /// Returns the CSSM_DL_DB_HANDLE for a given keychain reference. The handle is valid until the keychain reference is released.
    ///
    /// Parameter `keychain`: A keychain reference.
    ///
    /// Parameter `dldbHandle`: On return, a pointer to the CSSM_DL_DB_HANDLE for the given keychain.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// This API is deprecated for 10.7. It should nho longer be needed.
    ///
    /// # Safety
    ///
    /// `dldb_handle` must be a valid pointer.
    #[doc(alias = "SecKeychainGetDLDBHandle")]
    #[cfg(all(feature = "SecBase", feature = "cssmconfig", feature = "cssmtype"))]
    #[deprecated]
    #[inline]
    pub unsafe fn dldb_handle(
        keychain: Option<&SecKeychain>,
        dldb_handle: NonNull<CSSM_DL_DB_HANDLE>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainGetDLDBHandle(
                keychain: Option<&SecKeychain>,
                dldb_handle: NonNull<CSSM_DL_DB_HANDLE>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainGetDLDBHandle(keychain, dldb_handle) }
    }

    /// Retrieves the access for a keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain from which to copy the access.
    ///
    /// Parameter `access`: On return, a pointer to the access reference.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    ///
    /// # Safety
    ///
    /// `access` must be a valid pointer.
    #[doc(alias = "SecKeychainCopyAccess")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn copy_access(
        keychain: Option<&SecKeychain>,
        access: NonNull<*mut SecAccess>,
    ) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainCopyAccess(
                keychain: Option<&SecKeychain>,
                access: NonNull<*mut SecAccess>,
            ) -> OSStatus;
        }
        unsafe { SecKeychainCopyAccess(keychain, access) }
    }

    /// Sets the access for a keychain.
    ///
    /// Parameter `keychain`: A reference to the keychain for which to set the access.
    ///
    /// Parameter `access`: An access reference.
    ///
    /// Returns: A result code.  See "Security Error Codes" (SecBase.h).
    #[doc(alias = "SecKeychainSetAccess")]
    #[cfg(feature = "SecBase")]
    #[deprecated = "SecKeychain is deprecated"]
    #[inline]
    pub unsafe fn set_access(keychain: Option<&SecKeychain>, access: &SecAccess) -> OSStatus {
        extern "C-unwind" {
            fn SecKeychainSetAccess(keychain: Option<&SecKeychain>, access: &SecAccess)
                -> OSStatus;
        }
        unsafe { SecKeychainSetAccess(keychain, access) }
    }
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::version`"]
    pub fn SecKeychainGetVersion(return_vers: NonNull<u32>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::open`"]
    pub fn SecKeychainOpen(
        path_name: NonNull<c_char>,
        keychain: NonNull<*mut SecKeychain>,
    ) -> OSStatus;
}

#[cfg(feature = "SecBase")]
#[deprecated = "renamed to `SecKeychain::create`"]
#[inline]
pub unsafe extern "C-unwind" fn SecKeychainCreate(
    path_name: NonNull<c_char>,
    password_length: u32,
    password: *const c_void,
    prompt_user: bool,
    initial_access: Option<&SecAccess>,
    keychain: NonNull<*mut SecKeychain>,
) -> OSStatus {
    extern "C-unwind" {
        fn SecKeychainCreate(
            path_name: NonNull<c_char>,
            password_length: u32,
            password: *const c_void,
            prompt_user: Boolean,
            initial_access: Option<&SecAccess>,
            keychain: NonNull<*mut SecKeychain>,
        ) -> OSStatus;
    }
    unsafe {
        SecKeychainCreate(
            path_name,
            password_length,
            password,
            prompt_user as _,
            initial_access,
            keychain,
        )
    }
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::delete`"]
    pub fn SecKeychainDelete(keychain_or_array: Option<&SecKeychain>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::set_settings`"]
    pub fn SecKeychainSetSettings(
        keychain: Option<&SecKeychain>,
        new_settings: NonNull<SecKeychainSettings>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::copy_settings`"]
    pub fn SecKeychainCopySettings(
        keychain: Option<&SecKeychain>,
        out_settings: NonNull<SecKeychainSettings>,
    ) -> OSStatus;
}

#[cfg(feature = "SecBase")]
#[deprecated = "renamed to `SecKeychain::unlock`"]
#[inline]
pub unsafe extern "C-unwind" fn SecKeychainUnlock(
    keychain: Option<&SecKeychain>,
    password_length: u32,
    password: *const c_void,
    use_password: bool,
) -> OSStatus {
    extern "C-unwind" {
        fn SecKeychainUnlock(
            keychain: Option<&SecKeychain>,
            password_length: u32,
            password: *const c_void,
            use_password: Boolean,
        ) -> OSStatus;
    }
    unsafe { SecKeychainUnlock(keychain, password_length, password, use_password as _) }
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::lock`"]
    pub fn SecKeychainLock(keychain: Option<&SecKeychain>) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::lock_all`"]
    pub fn SecKeychainLockAll() -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::copy_default`"]
    pub fn SecKeychainCopyDefault(keychain: NonNull<*mut SecKeychain>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::set_default`"]
    pub fn SecKeychainSetDefault(keychain: Option<&SecKeychain>) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::copy_search_list`"]
    pub fn SecKeychainCopySearchList(search_list: NonNull<*const CFArray>) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::set_search_list`"]
    pub fn SecKeychainSetSearchList(search_list: &CFArray) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::copy_domain_default`"]
    pub fn SecKeychainCopyDomainDefault(
        domain: SecPreferencesDomain,
        keychain: NonNull<*mut SecKeychain>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::set_domain_default`"]
    pub fn SecKeychainSetDomainDefault(
        domain: SecPreferencesDomain,
        keychain: Option<&SecKeychain>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::copy_domain_search_list`"]
    pub fn SecKeychainCopyDomainSearchList(
        domain: SecPreferencesDomain,
        search_list: NonNull<*const CFArray>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::set_domain_search_list`"]
    pub fn SecKeychainSetDomainSearchList(
        domain: SecPreferencesDomain,
        search_list: &CFArray,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::set_preference_domain`"]
    pub fn SecKeychainSetPreferenceDomain(domain: SecPreferencesDomain) -> OSStatus;
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::preference_domain`"]
    pub fn SecKeychainGetPreferenceDomain(domain: NonNull<SecPreferencesDomain>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::status`"]
    pub fn SecKeychainGetStatus(
        keychain: Option<&SecKeychain>,
        keychain_status: NonNull<SecKeychainStatus>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::path`"]
    pub fn SecKeychainGetPath(
        keychain: Option<&SecKeychain>,
        io_path_length: NonNull<u32>,
        path_name: NonNull<c_char>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::attribute_info_for_item_id`"]
    pub fn SecKeychainAttributeInfoForItemID(
        keychain: Option<&SecKeychain>,
        item_id: u32,
        info: NonNull<*mut SecKeychainAttributeInfo>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::free_attribute_info`"]
    pub fn SecKeychainFreeAttributeInfo(info: NonNull<SecKeychainAttributeInfo>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(all(feature = "SecBase", feature = "libc"))]
    #[deprecated = "renamed to `SecKeychain::add_callback`"]
    pub fn SecKeychainAddCallback(
        callback_function: SecKeychainCallback,
        event_mask: SecKeychainEventMask,
        user_context: *mut c_void,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(all(feature = "SecBase", feature = "libc"))]
    #[deprecated = "renamed to `SecKeychain::remove_callback`"]
    pub fn SecKeychainRemoveCallback(callback_function: SecKeychainCallback) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::add_internet_password`"]
    pub fn SecKeychainAddInternetPassword(
        keychain: Option<&SecKeychain>,
        server_name_length: u32,
        server_name: *const c_char,
        security_domain_length: u32,
        security_domain: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        path_length: u32,
        path: *const c_char,
        port: u16,
        protocol: SecProtocolType,
        authentication_type: SecAuthenticationType,
        password_length: u32,
        password_data: NonNull<c_void>,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::find_internet_password`"]
    pub fn SecKeychainFindInternetPassword(
        keychain_or_array: Option<&CFType>,
        server_name_length: u32,
        server_name: *const c_char,
        security_domain_length: u32,
        security_domain: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        path_length: u32,
        path: *const c_char,
        port: u16,
        protocol: SecProtocolType,
        authentication_type: SecAuthenticationType,
        password_length: *mut u32,
        password_data: *mut *mut c_void,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::add_generic_password`"]
    pub fn SecKeychainAddGenericPassword(
        keychain: Option<&SecKeychain>,
        service_name_length: u32,
        service_name: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        password_length: u32,
        password_data: NonNull<c_void>,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::find_generic_password`"]
    pub fn SecKeychainFindGenericPassword(
        keychain_or_array: Option<&CFType>,
        service_name_length: u32,
        service_name: *const c_char,
        account_name_length: u32,
        account_name: *const c_char,
        password_length: *mut u32,
        password_data: *mut *mut c_void,
        item_ref: *mut *mut SecKeychainItem,
    ) -> OSStatus;
}

#[deprecated = "renamed to `SecKeychain::set_user_interaction_allowed`"]
#[inline]
pub unsafe extern "C-unwind" fn SecKeychainSetUserInteractionAllowed(state: bool) -> OSStatus {
    extern "C-unwind" {
        fn SecKeychainSetUserInteractionAllowed(state: Boolean) -> OSStatus;
    }
    unsafe { SecKeychainSetUserInteractionAllowed(state as _) }
}

extern "C-unwind" {
    #[deprecated = "renamed to `SecKeychain::user_interaction_allowed`"]
    pub fn SecKeychainGetUserInteractionAllowed(state: NonNull<Boolean>) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(all(feature = "SecBase", feature = "cssmconfig", feature = "cssmtype"))]
    #[deprecated = "renamed to `SecKeychain::csp_handle`"]
    pub fn SecKeychainGetCSPHandle(
        keychain: Option<&SecKeychain>,
        csp_handle: NonNull<CSSM_CSP_HANDLE>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(all(feature = "SecBase", feature = "cssmconfig", feature = "cssmtype"))]
    #[deprecated = "renamed to `SecKeychain::dldb_handle`"]
    pub fn SecKeychainGetDLDBHandle(
        keychain: Option<&SecKeychain>,
        dldb_handle: NonNull<CSSM_DL_DB_HANDLE>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::copy_access`"]
    pub fn SecKeychainCopyAccess(
        keychain: Option<&SecKeychain>,
        access: NonNull<*mut SecAccess>,
    ) -> OSStatus;
}

extern "C-unwind" {
    #[cfg(feature = "SecBase")]
    #[deprecated = "renamed to `SecKeychain::set_access`"]
    pub fn SecKeychainSetAccess(keychain: Option<&SecKeychain>, access: &SecAccess) -> OSStatus;
}