OSStatus AuthorizationCopyInfo (
    AuthorizationRef authorization,
    AuthorizationString tag,
    AuthorizationItemSet **info
);

OSStatus AuthorizationCopyInfo (
    AuthorizationRef _Nonnull authorization,
    AuthorizationString _Nullable tag,
    AuthorizationItemSet * _Nullable * _Nonnull info
);

OSStatus AuthorizationCopyPrivilegedReference (
    AuthorizationRef *authorization,
    AuthorizationFlags flags
);

OSStatus AuthorizationCopyPrivilegedReference (
    AuthorizationRef  _Nullable * _Nonnull authorization,
    AuthorizationFlags flags
);

OSStatus AuthorizationCopyRights (
    AuthorizationRef authorization,
    const AuthorizationRights *rights,
    const AuthorizationEnvironment *environment,
    AuthorizationFlags flags,
    AuthorizationRights **authorizedRights
);

OSStatus AuthorizationCopyRights (
    AuthorizationRef _Nonnull authorization,
    const AuthorizationRights * _Nonnull rights,
    const AuthorizationEnvironment * _Nullable environment,
    AuthorizationFlags flags,
    AuthorizationRights * _Nullable * _Nullable authorizedRights
);

void AuthorizationCopyRightsAsync (
    AuthorizationRef authorization,
    const AuthorizationRights *rights,
    const AuthorizationEnvironment *environment,
    AuthorizationFlags flags,
    AuthorizationAsyncCallback callbackBlock
);

void AuthorizationCopyRightsAsync (
    AuthorizationRef _Nonnull authorization,
    const AuthorizationRights * _Nonnull rights,
    const AuthorizationEnvironment * _Nullable environment,
    AuthorizationFlags flags,
    AuthorizationAsyncCallback _Nonnull callbackBlock
);

OSStatus AuthorizationCreate (
    const AuthorizationRights *rights,
    const AuthorizationEnvironment *environment,
    AuthorizationFlags flags,
    AuthorizationRef *authorization
);

OSStatus AuthorizationCreate (
    const AuthorizationRights * _Nullable rights,
    const AuthorizationEnvironment * _Nullable environment,
    AuthorizationFlags flags,
    AuthorizationRef  _Nullable * _Nullable authorization
);

OSStatus AuthorizationCreateFromExternalForm (
    const AuthorizationExternalForm *extForm,
    AuthorizationRef *authorization
);

OSStatus AuthorizationCreateFromExternalForm (
    const AuthorizationExternalForm * _Nonnull extForm,
    AuthorizationRef  _Nullable * _Nonnull authorization
);

OSStatus AuthorizationExecuteWithPrivileges (
    AuthorizationRef authorization,
    const char *pathToTool,
    AuthorizationFlags options,
    char *const *arguments,
    FILE **communicationsPipe
);

OSStatus AuthorizationExecuteWithPrivileges (
    AuthorizationRef _Nonnull authorization,
    const char * _Nonnull pathToTool,
    AuthorizationFlags options,
    char *const  _Nonnull * _Nonnull arguments,
    FILE * _Nullable * _Nullable communicationsPipe
);

OSStatus AuthorizationFree (
    AuthorizationRef authorization,
    AuthorizationFlags flags
);

OSStatus AuthorizationFree (
    AuthorizationRef _Nonnull authorization,
    AuthorizationFlags flags
);

OSStatus AuthorizationFreeItemSet (
    AuthorizationItemSet *set
);

OSStatus AuthorizationFreeItemSet (
    AuthorizationItemSet * _Nonnull set
);

OSStatus AuthorizationMakeExternalForm (
    AuthorizationRef authorization,
    AuthorizationExternalForm *extForm
);

OSStatus AuthorizationMakeExternalForm (
    AuthorizationRef _Nonnull authorization,
    AuthorizationExternalForm * _Nonnull extForm
);

OSStatus AuthorizationRightGet (
    const char *rightName,
    CFDictionaryRef *rightDefinition
);

OSStatus AuthorizationRightGet (
    const char * _Nonnull rightName,
    CFDictionaryRef  _Nullable * _Nullable rightDefinition
);

OSStatus AuthorizationRightRemove (
    AuthorizationRef authRef,
    const char *rightName
);

OSStatus AuthorizationRightRemove (
    AuthorizationRef _Nonnull authRef,
    const char * _Nonnull rightName
);

OSStatus AuthorizationRightSet (
    AuthorizationRef authRef,
    const char *rightName,
    CFTypeRef rightDefinition,
    CFStringRef descriptionKey,
    CFBundleRef bundle,
    CFStringRef localeTableName
);

OSStatus AuthorizationRightSet (
    AuthorizationRef _Nonnull authRef,
    const char * _Nonnull rightName,
    CFTypeRef _Nonnull rightDefinition,
    CFStringRef _Nullable descriptionKey,
    CFBundleRef _Nullable bundle,
    CFStringRef _Nullable localeTableName
);

OSStatus AuthorizationPluginCreate (
    const AuthorizationCallbacks *callbacks,
    AuthorizationPluginRef *outPlugin,
    const AuthorizationPluginInterface **outPluginInterface
);

OSStatus AuthorizationPluginCreate (
    const AuthorizationCallbacks * _Nonnull callbacks,
    AuthorizationPluginRef  _Nullable * _Nonnull outPlugin,
    const AuthorizationPluginInterface * _Nullable * _Nonnull outPluginInterface
);

OSStatus SessionGetInfo (
    SecuritySessionId session,
    SecuritySessionId *sessionId,
    SessionAttributeBits *attributes
);

OSStatus SessionGetInfo (
    SecuritySessionId session,
    SecuritySessionId * _Nullable sessionId,
    SessionAttributeBits * _Nullable attributes
);

OSStatus CMSDecoderCopyAllCerts (
    CMSDecoderRef cmsDecoder,
    CFArrayRef *certsOut
);

OSStatus CMSDecoderCopyAllCerts (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFArrayRef  _Nullable * _Nonnull certsOut
);

OSStatus CMSDecoderCopyContent (
    CMSDecoderRef cmsDecoder,
    CFDataRef *contentOut
);

OSStatus CMSDecoderCopyContent (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFDataRef  _Nullable * _Nonnull contentOut
);

OSStatus CMSDecoderCopyDetachedContent (
    CMSDecoderRef cmsDecoder,
    CFDataRef *detachedContentOut
);

OSStatus CMSDecoderCopyDetachedContent (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFDataRef  _Nullable * _Nonnull detachedContentOut
);

OSStatus CMSDecoderCopyEncapsulatedContentType (
    CMSDecoderRef cmsDecoder,
    CFDataRef *eContentTypeOut
);

OSStatus CMSDecoderCopyEncapsulatedContentType (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFDataRef  _Nullable * _Nonnull eContentTypeOut
);

OSStatus CMSDecoderCopySignerCert (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    SecCertificateRef *signerCertOut
);

OSStatus CMSDecoderCopySignerCert (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    SecCertificateRef  _Nullable * _Nonnull signerCertOut
);

OSStatus CMSDecoderCopySignerEmailAddress (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    CFStringRef *signerEmailAddressOut
);

OSStatus CMSDecoderCopySignerEmailAddress (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    CFStringRef  _Nullable * _Nonnull signerEmailAddressOut
);

OSStatus CMSDecoderCopySignerSigningTime (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    CFAbsoluteTime *signingTime
);

OSStatus CMSDecoderCopySignerSigningTime (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    CFAbsoluteTime * _Nonnull signingTime
);

OSStatus CMSDecoderCopySignerStatus (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    CFTypeRef policyOrArray,
    Boolean evaluateSecTrust,
    CMSSignerStatus *signerStatusOut,
    SecTrustRef *secTrustOut,
    OSStatus *certVerifyResultCodeOut
);

OSStatus CMSDecoderCopySignerStatus (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    CFTypeRef _Nonnull policyOrArray,
    Boolean evaluateSecTrust,
    CMSSignerStatus * _Nullable signerStatusOut,
    SecTrustRef  _Nullable * _Nullable secTrustOut,
    OSStatus * _Nullable certVerifyResultCodeOut
);

OSStatus CMSDecoderCopySignerTimestamp (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    CFAbsoluteTime *timestamp
);

OSStatus CMSDecoderCopySignerTimestamp (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    CFAbsoluteTime * _Nonnull timestamp
);

OSStatus CMSDecoderCopySignerTimestampCertificates (
    CMSDecoderRef cmsDecoder,
    size_t signerIndex,
    CFArrayRef *certificateRefs
);

OSStatus CMSDecoderCopySignerTimestampCertificates (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t signerIndex,
    CFArrayRef  _Nullable * _Nonnull certificateRefs
);

OSStatus CMSDecoderCopySignerTimestampWithPolicy (
    CMSDecoderRef cmsDecoder,
    CFTypeRef timeStampPolicy,
    size_t signerIndex,
    CFAbsoluteTime *timestamp
);

OSStatus CMSDecoderCopySignerTimestampWithPolicy (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFTypeRef _Nullable timeStampPolicy,
    size_t signerIndex,
    CFAbsoluteTime * _Nonnull timestamp
);

OSStatus CMSDecoderCreate (
    CMSDecoderRef *cmsDecoderOut
);

OSStatus CMSDecoderCreate (
    CMSDecoderRef  _Nullable * _Nonnull cmsDecoderOut
);

OSStatus CMSDecoderFinalizeMessage (
    CMSDecoderRef cmsDecoder
);

OSStatus CMSDecoderFinalizeMessage (
    CMSDecoderRef _Nonnull cmsDecoder
);

OSStatus CMSDecoderGetNumSigners (
    CMSDecoderRef cmsDecoder,
    size_t *numSignersOut
);

OSStatus CMSDecoderGetNumSigners (
    CMSDecoderRef _Nonnull cmsDecoder,
    size_t * _Nonnull numSignersOut
);

OSStatus CMSDecoderIsContentEncrypted (
    CMSDecoderRef cmsDecoder,
    Boolean *isEncryptedOut
);

OSStatus CMSDecoderIsContentEncrypted (
    CMSDecoderRef _Nonnull cmsDecoder,
    Boolean * _Nonnull isEncryptedOut
);

OSStatus CMSDecoderSetDetachedContent (
    CMSDecoderRef cmsDecoder,
    CFDataRef detachedContent
);

OSStatus CMSDecoderSetDetachedContent (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFDataRef _Nonnull detachedContent
);

OSStatus CMSDecoderSetSearchKeychain (
    CMSDecoderRef cmsDecoder,
    CFTypeRef keychainOrArray
);

OSStatus CMSDecoderSetSearchKeychain (
    CMSDecoderRef _Nonnull cmsDecoder,
    CFTypeRef _Nonnull keychainOrArray
);

OSStatus CMSDecoderUpdateMessage (
    CMSDecoderRef cmsDecoder,
    const void *msgBytes,
    size_t msgBytesLen
);

OSStatus CMSDecoderUpdateMessage (
    CMSDecoderRef _Nonnull cmsDecoder,
    const void * _Nonnull msgBytes,
    size_t msgBytesLen
);

OSStatus CMSEncode (
    CFTypeRef signers,
    CFTypeRef recipients,
    const CSSM_OID *eContentType,
    Boolean detachedContent,
    CMSSignedAttributes signedAttributes,
    const void *content,
    size_t contentLen,
    CFDataRef *encodedContentOut
);

OSStatus CMSEncode (
    CFTypeRef _Nullable signers,
    CFTypeRef _Nullable recipients,
    const CSSM_OID * _Nullable eContentType,
    Boolean detachedContent,
    CMSSignedAttributes signedAttributes,
    const void * _Nonnull content,
    size_t contentLen,
    CFDataRef  _Nullable * _Nonnull encodedContentOut
);

OSStatus CMSEncodeContent (
    CFTypeRef signers,
    CFTypeRef recipients,
    CFTypeRef eContentTypeOID,
    Boolean detachedContent,
    CMSSignedAttributes signedAttributes,
    const void *content,
    size_t contentLen,
    CFDataRef *encodedContentOut
);

OSStatus CMSEncodeContent (
    CFTypeRef _Nullable signers,
    CFTypeRef _Nullable recipients,
    CFTypeRef _Nullable eContentTypeOID,
    Boolean detachedContent,
    CMSSignedAttributes signedAttributes,
    const void * _Nonnull content,
    size_t contentLen,
    CFDataRef  _Nullable * _Nullable encodedContentOut
);

OSStatus CMSEncoderAddRecipients (
    CMSEncoderRef cmsEncoder,
    CFTypeRef recipientOrArray
);

OSStatus CMSEncoderAddRecipients (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFTypeRef _Nonnull recipientOrArray
);

OSStatus CMSEncoderAddSignedAttributes (
    CMSEncoderRef cmsEncoder,
    CMSSignedAttributes signedAttributes
);

OSStatus CMSEncoderAddSignedAttributes (
    CMSEncoderRef _Nonnull cmsEncoder,
    CMSSignedAttributes signedAttributes
);

OSStatus CMSEncoderAddSigners (
    CMSEncoderRef cmsEncoder,
    CFTypeRef signerOrArray
);

OSStatus CMSEncoderAddSigners (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFTypeRef _Nonnull signerOrArray
);

OSStatus CMSEncoderAddSupportingCerts (
    CMSEncoderRef cmsEncoder,
    CFTypeRef certOrArray
);

OSStatus CMSEncoderAddSupportingCerts (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFTypeRef _Nonnull certOrArray
);

OSStatus CMSEncoderCopyEncapsulatedContentType (
    CMSEncoderRef cmsEncoder,
    CFDataRef *eContentTypeOut
);

OSStatus CMSEncoderCopyEncapsulatedContentType (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFDataRef  _Nullable * _Nonnull eContentTypeOut
);

OSStatus CMSEncoderCopyEncodedContent (
    CMSEncoderRef cmsEncoder,
    CFDataRef *encodedContentOut
);

OSStatus CMSEncoderCopyEncodedContent (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFDataRef  _Nullable * _Nonnull encodedContentOut
);

OSStatus CMSEncoderCopyRecipients (
    CMSEncoderRef cmsEncoder,
    CFArrayRef *recipientsOut
);

OSStatus CMSEncoderCopyRecipients (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFArrayRef  _Nullable * _Nonnull recipientsOut
);

OSStatus CMSEncoderCopySigners (
    CMSEncoderRef cmsEncoder,
    CFArrayRef *signersOut
);

OSStatus CMSEncoderCopySigners (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFArrayRef  _Nullable * _Nonnull signersOut
);

OSStatus CMSEncoderCopySignerTimestamp (
    CMSEncoderRef cmsEncoder,
    size_t signerIndex,
    CFAbsoluteTime *timestamp
);

OSStatus CMSEncoderCopySignerTimestamp (
    CMSEncoderRef _Nonnull cmsEncoder,
    size_t signerIndex,
    CFAbsoluteTime * _Nonnull timestamp
);

OSStatus CMSEncoderCopySignerTimestampWithPolicy (
    CMSEncoderRef cmsEncoder,
    CFTypeRef timeStampPolicy,
    size_t signerIndex,
    CFAbsoluteTime *timestamp
);

OSStatus CMSEncoderCopySignerTimestampWithPolicy (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFTypeRef _Nullable timeStampPolicy,
    size_t signerIndex,
    CFAbsoluteTime * _Nonnull timestamp
);

OSStatus CMSEncoderCopySupportingCerts (
    CMSEncoderRef cmsEncoder,
    CFArrayRef *certsOut
);

OSStatus CMSEncoderCopySupportingCerts (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFArrayRef  _Nullable * _Nonnull certsOut
);

OSStatus CMSEncoderCreate (
    CMSEncoderRef *cmsEncoderOut
);

OSStatus CMSEncoderCreate (
    CMSEncoderRef  _Nullable * _Nonnull cmsEncoderOut
);

OSStatus CMSEncoderGetCertificateChainMode (
    CMSEncoderRef cmsEncoder,
    CMSCertificateChainMode *chainModeOut
);

OSStatus CMSEncoderGetCertificateChainMode (
    CMSEncoderRef _Nonnull cmsEncoder,
    CMSCertificateChainMode * _Nonnull chainModeOut
);

OSStatus CMSEncoderGetHasDetachedContent (
    CMSEncoderRef cmsEncoder,
    Boolean *detachedContentOut
);

OSStatus CMSEncoderGetHasDetachedContent (
    CMSEncoderRef _Nonnull cmsEncoder,
    Boolean * _Nonnull detachedContentOut
);

OSStatus CMSEncoderSetCertificateChainMode (
    CMSEncoderRef cmsEncoder,
    CMSCertificateChainMode chainMode
);

OSStatus CMSEncoderSetCertificateChainMode (
    CMSEncoderRef _Nonnull cmsEncoder,
    CMSCertificateChainMode chainMode
);

OSStatus CMSEncoderSetEncapsulatedContentType (
    CMSEncoderRef cmsEncoder,
    const CSSM_OID *eContentType
);

OSStatus CMSEncoderSetEncapsulatedContentType (
    CMSEncoderRef _Nonnull cmsEncoder,
    const CSSM_OID * _Nonnull eContentType
);

OSStatus CMSEncoderSetEncapsulatedContentTypeOID (
    CMSEncoderRef cmsEncoder,
    CFTypeRef eContentTypeOID
);

OSStatus CMSEncoderSetEncapsulatedContentTypeOID (
    CMSEncoderRef _Nonnull cmsEncoder,
    CFTypeRef _Nonnull eContentTypeOID
);

OSStatus CMSEncoderSetHasDetachedContent (
    CMSEncoderRef cmsEncoder,
    Boolean detachedContent
);

OSStatus CMSEncoderSetHasDetachedContent (
    CMSEncoderRef _Nonnull cmsEncoder,
    Boolean detachedContent
);

OSStatus CMSEncoderUpdateContent (
    CMSEncoderRef cmsEncoder,
    const void *content,
    size_t contentLen
);

OSStatus CMSEncoderUpdateContent (
    CMSEncoderRef _Nonnull cmsEncoder,
    const void * _Nonnull content,
    size_t contentLen
);

OSStatus SecAccessCopyACLList (
    SecAccessRef accessRef,
    CFArrayRef *aclList
);

OSStatus SecAccessCopyACLList (
    SecAccessRef _Nonnull accessRef,
    CFArrayRef  _Nullable * _Nonnull aclList
);

CFArrayRef SecAccessCopyMatchingACLList (
    SecAccessRef accessRef,
    CFTypeRef authorizationTag
);

CFArrayRef _Nullable SecAccessCopyMatchingACLList (
    SecAccessRef _Nonnull accessRef,
    CFTypeRef _Nonnull authorizationTag
);

OSStatus SecAccessCopyOwnerAndACL (
    SecAccessRef accessRef,
    uid_t *userId,
    gid_t *groupId,
    SecAccessOwnerType *ownerType,
    CFArrayRef *aclList
);

OSStatus SecAccessCopyOwnerAndACL (
    SecAccessRef _Nonnull accessRef,
    uid_t * _Nullable userId,
    gid_t * _Nullable groupId,
    SecAccessOwnerType * _Nullable ownerType,
    CFArrayRef  _Nullable * _Nullable aclList
);

OSStatus SecAccessCopySelectedACLList (
    SecAccessRef accessRef,
    CSSM_ACL_AUTHORIZATION_TAG action,
    CFArrayRef *aclList
);

OSStatus SecAccessCopySelectedACLList (
    SecAccessRef _Nonnull accessRef,
    CSSM_ACL_AUTHORIZATION_TAG action,
    CFArrayRef  _Nullable * _Nonnull aclList
);

OSStatus SecAccessCreate (
    CFStringRef descriptor,
    CFArrayRef trustedlist,
    SecAccessRef *accessRef
);

OSStatus SecAccessCreate (
    CFStringRef _Nonnull descriptor,
    CFArrayRef _Nullable trustedlist,
    SecAccessRef  _Nullable * _Nonnull accessRef
);

OSStatus SecAccessCreateFromOwnerAndACL (
    const CSSM_ACL_OWNER_PROTOTYPE *owner,
    uint32 aclCount,
    const CSSM_ACL_ENTRY_INFO *acls,
    SecAccessRef *accessRef
);

OSStatus SecAccessCreateFromOwnerAndACL (
    const CSSM_ACL_OWNER_PROTOTYPE * _Nonnull owner,
    uint32 aclCount,
    const CSSM_ACL_ENTRY_INFO * _Nonnull acls,
    SecAccessRef  _Nullable * _Nonnull accessRef
);

SecAccessRef SecAccessCreateWithOwnerAndACL (
    uid_t userId,
    gid_t groupId,
    SecAccessOwnerType ownerType,
    CFArrayRef acls,
    CFErrorRef *error
);

SecAccessRef _Nullable SecAccessCreateWithOwnerAndACL (
    uid_t userId,
    gid_t groupId,
    SecAccessOwnerType ownerType,
    CFArrayRef _Nullable acls,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecAccessGetOwnerAndACL (
    SecAccessRef accessRef,
    CSSM_ACL_OWNER_PROTOTYPE_PTR *owner,
    uint32 *aclCount,
    CSSM_ACL_ENTRY_INFO_PTR *acls
);

OSStatus SecAccessGetOwnerAndACL (
    SecAccessRef _Nonnull accessRef,
    CSSM_ACL_OWNER_PROTOTYPE_PTR  _Nullable * _Nonnull owner,
    uint32 * _Nonnull aclCount,
    CSSM_ACL_ENTRY_INFO_PTR  _Nullable * _Nonnull acls
);

SecAccessControlRef SecAccessControlCreateWithFlags (
    CFAllocatorRef allocator,
    CFTypeRef protection,
    SecAccessControlCreateFlags flags,
    CFErrorRef *error
);

SecAccessControlRef _Nullable SecAccessControlCreateWithFlags (
    CFAllocatorRef _Nullable allocator,
    CFTypeRef _Nonnull protection,
    SecAccessControlCreateFlags flags,
    CFErrorRef  _Nullable * _Nullable error
);

CFArrayRef SecACLCopyAuthorizations (
    SecACLRef acl
);

CFArrayRef _Nonnull SecACLCopyAuthorizations (
    SecACLRef _Nonnull acl
);

OSStatus SecACLCopyContents (
    SecACLRef acl,
    CFArrayRef *applicationList,
    CFStringRef *description,
    SecKeychainPromptSelector *promptSelector
);

OSStatus SecACLCopyContents (
    SecACLRef _Nonnull acl,
    CFArrayRef  _Nullable * _Nonnull applicationList,
    CFStringRef  _Nullable * _Nonnull description,
    SecKeychainPromptSelector * _Nonnull promptSelector
);

OSStatus SecACLCopySimpleContents (
    SecACLRef acl,
    CFArrayRef *applicationList,
    CFStringRef *description,
    CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR *promptSelector
);

OSStatus SecACLCopySimpleContents (
    SecACLRef _Nonnull acl,
    CFArrayRef  _Nullable * _Nonnull applicationList,
    CFStringRef  _Nullable * _Nonnull description,
    CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR * _Nonnull promptSelector
);

OSStatus SecACLCreateFromSimpleContents (
    SecAccessRef access,
    CFArrayRef applicationList,
    CFStringRef description,
    const CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR *promptSelector,
    SecACLRef *newAcl
);

OSStatus SecACLCreateFromSimpleContents (
    SecAccessRef _Nonnull access,
    CFArrayRef _Nullable applicationList,
    CFStringRef _Nonnull description,
    const CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR * _Nonnull promptSelector,
    SecACLRef  _Nullable * _Nonnull newAcl
);

OSStatus SecACLCreateWithSimpleContents (
    SecAccessRef access,
    CFArrayRef applicationList,
    CFStringRef description,
    SecKeychainPromptSelector promptSelector,
    SecACLRef *newAcl
);

OSStatus SecACLCreateWithSimpleContents (
    SecAccessRef _Nonnull access,
    CFArrayRef _Nullable applicationList,
    CFStringRef _Nonnull description,
    SecKeychainPromptSelector promptSelector,
    SecACLRef  _Nullable * _Nonnull newAcl
);

OSStatus SecACLGetAuthorizations (
    SecACLRef acl,
    CSSM_ACL_AUTHORIZATION_TAG *tags,
    uint32 *tagCount
);

OSStatus SecACLGetAuthorizations (
    SecACLRef _Nonnull acl,
    CSSM_ACL_AUTHORIZATION_TAG * _Nonnull tags,
    uint32 * _Nonnull tagCount
);

OSStatus SecACLRemove (
    SecACLRef aclRef
);

OSStatus SecACLRemove (
    SecACLRef _Nonnull aclRef
);

OSStatus SecACLSetAuthorizations (
    SecACLRef acl,
    CSSM_ACL_AUTHORIZATION_TAG *tags,
    uint32 tagCount
);

OSStatus SecACLSetAuthorizations (
    SecACLRef _Nonnull acl,
    CSSM_ACL_AUTHORIZATION_TAG * _Nonnull tags,
    uint32 tagCount
);

OSStatus SecACLSetContents (
    SecACLRef acl,
    CFArrayRef applicationList,
    CFStringRef description,
    SecKeychainPromptSelector promptSelector
);

OSStatus SecACLSetContents (
    SecACLRef _Nonnull acl,
    CFArrayRef _Nullable applicationList,
    CFStringRef _Nonnull description,
    SecKeychainPromptSelector promptSelector
);

OSStatus SecACLSetSimpleContents (
    SecACLRef acl,
    CFArrayRef applicationList,
    CFStringRef description,
    const CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR *promptSelector
);

OSStatus SecACLSetSimpleContents (
    SecACLRef _Nonnull acl,
    CFArrayRef _Nullable applicationList,
    CFStringRef _Nonnull description,
    const CSSM_ACL_KEYCHAIN_PROMPT_SELECTOR * _Nonnull promptSelector
);

OSStatus SecACLUpdateAuthorizations (
    SecACLRef acl,
    CFArrayRef authorizations
);

OSStatus SecACLUpdateAuthorizations (
    SecACLRef _Nonnull acl,
    CFArrayRef _Nonnull authorizations
);

OSStatus SecAsn1AllocCopy (
    SecAsn1CoderRef coder,
    const void *src,
    size_t len,
    SecAsn1Item *dest
);

OSStatus SecAsn1AllocCopy (
    SecAsn1CoderRef _Nonnull coder,
    const void * _Nonnull src,
    size_t len,
    SecAsn1Item * _Nonnull dest
);

OSStatus SecAsn1AllocCopyItem (
    SecAsn1CoderRef coder,
    const SecAsn1Item *src,
    SecAsn1Item *dest
);

OSStatus SecAsn1AllocCopyItem (
    SecAsn1CoderRef _Nonnull coder,
    const SecAsn1Item * _Nonnull src,
    SecAsn1Item * _Nonnull dest
);

OSStatus SecAsn1AllocItem (
    SecAsn1CoderRef coder,
    SecAsn1Item *item,
    size_t len
);

OSStatus SecAsn1AllocItem (
    SecAsn1CoderRef _Nonnull coder,
    SecAsn1Item * _Nonnull item,
    size_t len
);

OSStatus SecAsn1CoderCreate (
    SecAsn1CoderRef *coder
);

OSStatus SecAsn1CoderCreate (
    SecAsn1CoderRef  _Nullable * _Nonnull coder
);

OSStatus SecAsn1CoderRelease (
    SecAsn1CoderRef coder
);

OSStatus SecAsn1CoderRelease (
    SecAsn1CoderRef _Nonnull coder
);

OSStatus SecAsn1Decode (
    SecAsn1CoderRef coder,
    const void *src,
    size_t len,
    const SecAsn1Template *templates,
    void *dest
);

OSStatus SecAsn1Decode (
    SecAsn1CoderRef _Nonnull coder,
    const void * _Nonnull src,
    size_t len,
    const SecAsn1Template * _Nonnull templates,
    void * _Nonnull dest
);

OSStatus SecAsn1DecodeData (
    SecAsn1CoderRef coder,
    const SecAsn1Item *src,
    const SecAsn1Template *templ,
    void *dest
);

OSStatus SecAsn1DecodeData (
    SecAsn1CoderRef _Nonnull coder,
    const SecAsn1Item * _Nonnull src,
    const SecAsn1Template * _Nonnull templ,
    void * _Nonnull dest
);

OSStatus SecAsn1EncodeItem (
    SecAsn1CoderRef coder,
    const void *src,
    const SecAsn1Template *templates,
    SecAsn1Item *dest
);

OSStatus SecAsn1EncodeItem (
    SecAsn1CoderRef _Nonnull coder,
    const void * _Nonnull src,
    const SecAsn1Template * _Nonnull templates,
    SecAsn1Item * _Nonnull dest
);

void * SecAsn1Malloc (
    SecAsn1CoderRef coder,
    size_t len
);

void * _Nonnull SecAsn1Malloc (
    SecAsn1CoderRef _Nonnull coder,
    size_t len
);

bool SecAsn1OidCompare (
    const SecAsn1Oid *oid1,
    const SecAsn1Oid *oid2
);

bool SecAsn1OidCompare (
    const SecAsn1Oid * _Nonnull oid1,
    const SecAsn1Oid * _Nonnull oid2
);

CFStringRef SecCopyErrorMessageString (
    OSStatus status,
    void *reserved
);

CFStringRef _Nullable SecCopyErrorMessageString (
    OSStatus status,
    void * _Nullable reserved
);

OSStatus SecCertificateAddToKeychain (
    SecCertificateRef certificate,
    SecKeychainRef keychain
);

OSStatus SecCertificateAddToKeychain (
    SecCertificateRef _Nonnull certificate,
    SecKeychainRef _Nullable keychain
);

OSStatus SecCertificateCopyCommonName (
    SecCertificateRef certificate,
    CFStringRef *commonName
);

OSStatus SecCertificateCopyCommonName (
    SecCertificateRef _Nonnull certificate,
    CFStringRef  _Nullable * _Nonnull commonName
);

CFDataRef SecCertificateCopyData (
    SecCertificateRef certificate
);

CFDataRef _Nonnull SecCertificateCopyData (
    SecCertificateRef _Nonnull certificate
);

OSStatus SecCertificateCopyEmailAddresses (
    SecCertificateRef certificate,
    CFArrayRef *emailAddresses
);

OSStatus SecCertificateCopyEmailAddresses (
    SecCertificateRef _Nonnull certificate,
    CFArrayRef  _Nullable * _Nonnull emailAddresses
);

CFStringRef SecCertificateCopyLongDescription (
    CFAllocatorRef alloc,
    SecCertificateRef certificate,
    CFErrorRef *error
);

CFStringRef _Nullable SecCertificateCopyLongDescription (
    CFAllocatorRef _Nullable alloc,
    SecCertificateRef _Nonnull certificate,
    CFErrorRef  _Nullable * _Nullable error
);

CFDataRef SecCertificateCopyNormalizedIssuerContent (
    SecCertificateRef certificate,
    CFErrorRef *error
);

CFDataRef _Nullable SecCertificateCopyNormalizedIssuerContent (
    SecCertificateRef _Nonnull certificate,
    CFErrorRef  _Nullable * _Nullable error
);

CFDataRef SecCertificateCopyNormalizedSubjectContent (
    SecCertificateRef certificate,
    CFErrorRef *error
);

CFDataRef _Nullable SecCertificateCopyNormalizedSubjectContent (
    SecCertificateRef _Nonnull certificate,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecCertificateCopyPreference (
    CFStringRef name,
    uint32 keyUsage,
    SecCertificateRef *certificate
);

OSStatus SecCertificateCopyPreference (
    CFStringRef _Nonnull name,
    uint32 keyUsage,
    SecCertificateRef  _Nullable * _Nonnull certificate
);

SecCertificateRef SecCertificateCopyPreferred (
    CFStringRef name,
    CFArrayRef keyUsage
);

SecCertificateRef _Nullable SecCertificateCopyPreferred (
    CFStringRef _Nonnull name,
    CFArrayRef _Nullable keyUsage
);

OSStatus SecCertificateCopyPublicKey (
    SecCertificateRef certificate,
    SecKeyRef *key
);

OSStatus SecCertificateCopyPublicKey (
    SecCertificateRef _Nonnull certificate,
    SecKeyRef  _Nullable * _Nonnull key
);

CFDataRef SecCertificateCopySerialNumber (
    SecCertificateRef certificate,
    CFErrorRef *error
);

CFDataRef _Nullable SecCertificateCopySerialNumber (
    SecCertificateRef _Nonnull certificate,
    CFErrorRef  _Nullable * _Nullable error
);

CFStringRef SecCertificateCopyShortDescription (
    CFAllocatorRef alloc,
    SecCertificateRef certificate,
    CFErrorRef *error
);

CFStringRef _Nullable SecCertificateCopyShortDescription (
    CFAllocatorRef _Nullable alloc,
    SecCertificateRef _Nonnull certificate,
    CFErrorRef  _Nullable * _Nullable error
);

CFStringRef SecCertificateCopySubjectSummary (
    SecCertificateRef certificate
);

CFStringRef _Nonnull SecCertificateCopySubjectSummary (
    SecCertificateRef _Nonnull certificate
);

CFDictionaryRef SecCertificateCopyValues (
    SecCertificateRef certificate,
    CFArrayRef keys,
    CFErrorRef *error
);

CFDictionaryRef _Nullable SecCertificateCopyValues (
    SecCertificateRef _Nonnull certificate,
    CFArrayRef _Nullable keys,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecCertificateCreateFromData (
    const CSSM_DATA *data,
    CSSM_CERT_TYPE type,
    CSSM_CERT_ENCODING encoding,
    SecCertificateRef *certificate
);

OSStatus SecCertificateCreateFromData (
    const CSSM_DATA * _Nonnull data,
    CSSM_CERT_TYPE type,
    CSSM_CERT_ENCODING encoding,
    SecCertificateRef  _Nullable * _Nonnull certificate
);

SecCertificateRef SecCertificateCreateWithData (
    CFAllocatorRef allocator,
    CFDataRef data
);

SecCertificateRef _Nullable SecCertificateCreateWithData (
    CFAllocatorRef _Nullable allocator,
    CFDataRef _Nonnull data
);

OSStatus SecCertificateGetAlgorithmID (
    SecCertificateRef certificate,
    const CSSM_X509_ALGORITHM_IDENTIFIER **algid
);

OSStatus SecCertificateGetAlgorithmID (
    SecCertificateRef _Nonnull certificate,
    const CSSM_X509_ALGORITHM_IDENTIFIER * _Nullable * _Nonnull algid
);

OSStatus SecCertificateGetCLHandle (
    SecCertificateRef certificate,
    CSSM_CL_HANDLE *clHandle
);

OSStatus SecCertificateGetCLHandle (
    SecCertificateRef _Nonnull certificate,
    CSSM_CL_HANDLE * _Nonnull clHandle
);

OSStatus SecCertificateGetData (
    SecCertificateRef certificate,
    CSSM_DATA_PTR data
);

OSStatus SecCertificateGetData (
    SecCertificateRef _Nonnull certificate,
    CSSM_DATA_PTR _Nonnull data
);

OSStatus SecCertificateGetIssuer (
    SecCertificateRef certificate,
    const CSSM_X509_NAME **issuer
);

OSStatus SecCertificateGetIssuer (
    SecCertificateRef _Nonnull certificate,
    const CSSM_X509_NAME * _Nullable * _Nonnull issuer
);

OSStatus SecCertificateGetSubject (
    SecCertificateRef certificate,
    const CSSM_X509_NAME **subject
);

OSStatus SecCertificateGetSubject (
    SecCertificateRef _Nonnull certificate,
    const CSSM_X509_NAME * _Nullable * _Nonnull subject
);

OSStatus SecCertificateGetType (
    SecCertificateRef certificate,
    CSSM_CERT_TYPE *certificateType
);

OSStatus SecCertificateGetType (
    SecCertificateRef _Nonnull certificate,
    CSSM_CERT_TYPE * _Nonnull certificateType
);

OSStatus SecCertificateSetPreference (
    SecCertificateRef certificate,
    CFStringRef name,
    uint32 keyUsage,
    CFDateRef date
);

OSStatus SecCertificateSetPreference (
    SecCertificateRef _Nonnull certificate,
    CFStringRef _Nonnull name,
    uint32 keyUsage,
    CFDateRef _Nullable date
);

OSStatus SecCertificateSetPreferred (
    SecCertificateRef certificate,
    CFStringRef name,
    CFArrayRef keyUsage
);

OSStatus SecCertificateSetPreferred (
    SecCertificateRef _Nullable certificate,
    CFStringRef _Nonnull name,
    CFArrayRef _Nullable keyUsage
);

OSStatus SecCodeCheckValidity (
    SecCodeRef code,
    SecCSFlags flags,
    SecRequirementRef requirement
);

OSStatus SecCodeCheckValidity (
    SecCodeRef _Nonnull code,
    SecCSFlags flags,
    SecRequirementRef _Nullable requirement
);

OSStatus SecCodeCheckValidityWithErrors (
    SecCodeRef code,
    SecCSFlags flags,
    SecRequirementRef requirement,
    CFErrorRef *errors
);

OSStatus SecCodeCheckValidityWithErrors (
    SecCodeRef _Nonnull code,
    SecCSFlags flags,
    SecRequirementRef _Nullable requirement,
    CFErrorRef  _Nullable * _Nullable errors
);

OSStatus SecCodeCopyDesignatedRequirement (
    SecStaticCodeRef code,
    SecCSFlags flags,
    SecRequirementRef *requirement
);

OSStatus SecCodeCopyDesignatedRequirement (
    SecStaticCodeRef _Nonnull code,
    SecCSFlags flags,
    SecRequirementRef  _Nullable * _Nonnull requirement
);

OSStatus SecCodeCopyGuestWithAttributes (
    SecCodeRef host,
    CFDictionaryRef attributes,
    SecCSFlags flags,
    SecCodeRef *guest
);

OSStatus SecCodeCopyGuestWithAttributes (
    SecCodeRef _Nullable host,
    CFDictionaryRef _Nullable attributes,
    SecCSFlags flags,
    SecCodeRef  _Nullable * _Nonnull guest
);

OSStatus SecCodeCopyHost (
    SecCodeRef guest,
    SecCSFlags flags,
    SecCodeRef *host
);

OSStatus SecCodeCopyHost (
    SecCodeRef _Nonnull guest,
    SecCSFlags flags,
    SecCodeRef  _Nullable * _Nonnull host
);

OSStatus SecCodeCopyPath (
    SecStaticCodeRef staticCode,
    SecCSFlags flags,
    CFURLRef *path
);

OSStatus SecCodeCopyPath (
    SecStaticCodeRef _Nonnull staticCode,
    SecCSFlags flags,
    CFURLRef  _Nullable * _Nonnull path
);

OSStatus SecCodeCopySelf (
    SecCSFlags flags,
    SecCodeRef *self
);

OSStatus SecCodeCopySelf (
    SecCSFlags flags,
    SecCodeRef  _Nullable * _Nonnull self
);

OSStatus SecCodeCopySigningInformation (
    SecStaticCodeRef code,
    SecCSFlags flags,
    CFDictionaryRef *information
);

OSStatus SecCodeCopySigningInformation (
    SecStaticCodeRef _Nonnull code,
    SecCSFlags flags,
    CFDictionaryRef  _Nullable * _Nonnull information
);

OSStatus SecCodeCopyStaticCode (
    SecCodeRef code,
    SecCSFlags flags,
    SecStaticCodeRef *staticCode
);

OSStatus SecCodeCopyStaticCode (
    SecCodeRef _Nonnull code,
    SecCSFlags flags,
    SecStaticCodeRef  _Nullable * _Nonnull staticCode
);

OSStatus SecCodeMapMemory (
    SecStaticCodeRef code,
    SecCSFlags flags
);

OSStatus SecCodeMapMemory (
    SecStaticCodeRef _Nonnull code,
    SecCSFlags flags
);

OSStatus SecHostCreateGuest (
    SecGuestRef host,
    uint32_t status,
    CFURLRef path,
    CFDictionaryRef attributes,
    SecCSFlags flags,
    SecGuestRef *newGuest
);

OSStatus SecHostCreateGuest (
    SecGuestRef host,
    uint32_t status,
    CFURLRef _Nonnull path,
    CFDictionaryRef _Nullable attributes,
    SecCSFlags flags,
    SecGuestRef * _Nonnull newGuest
);

OSStatus SecHostSelectedGuest (
    SecCSFlags flags,
    SecGuestRef *guestRef
);

OSStatus SecHostSelectedGuest (
    SecCSFlags flags,
    SecGuestRef * _Nonnull guestRef
);

OSStatus SecHostSetGuestStatus (
    SecGuestRef guestRef,
    uint32_t status,
    CFDictionaryRef attributes,
    SecCSFlags flags
);

OSStatus SecHostSetGuestStatus (
    SecGuestRef guestRef,
    uint32_t status,
    CFDictionaryRef _Nullable attributes,
    SecCSFlags flags
);

CFTypeRef SecTranformCustomGetAttribute (
    SecTransformImplementationRef ref,
    SecTransformStringOrAttributeRef attribute,
    SecTransformMetaAttributeType type
);

CFTypeRef _Nullable SecTranformCustomGetAttribute (
    SecTransformImplementationRef _Nonnull ref,
    SecTransformStringOrAttributeRef _Nonnull attribute,
    SecTransformMetaAttributeType type
);

SecTransformRef SecTransformCreate (
    CFStringRef name,
    CFErrorRef *error
);

SecTransformRef _Nullable SecTransformCreate (
    CFStringRef _Nonnull name,
    CFErrorRef  _Nullable * _Nullable error
);

CFTypeRef SecTransformCustomGetAttribute (
    SecTransformImplementationRef ref,
    SecTransformStringOrAttributeRef attribute,
    SecTransformMetaAttributeType type
);

CFTypeRef _Nullable SecTransformCustomGetAttribute (
    SecTransformImplementationRef _Nonnull ref,
    SecTransformStringOrAttributeRef _Nonnull attribute,
    SecTransformMetaAttributeType type
);

CFTypeRef SecTransformCustomSetAttribute (
    SecTransformImplementationRef ref,
    SecTransformStringOrAttributeRef attribute,
    SecTransformMetaAttributeType type,
    CFTypeRef value
);

CFTypeRef _Nullable SecTransformCustomSetAttribute (
    SecTransformImplementationRef _Nonnull ref,
    SecTransformStringOrAttributeRef _Nonnull attribute,
    SecTransformMetaAttributeType type,
    CFTypeRef _Nullable value
);

CFTypeRef SecTransformNoData (
    void
);

CFTypeRef _Nonnull SecTransformNoData (
    void
);

CFTypeRef SecTransformPushbackAttribute (
    SecTransformImplementationRef ref,
    SecTransformStringOrAttributeRef attribute,
    CFTypeRef value
);

CFTypeRef _Nullable SecTransformPushbackAttribute (
    SecTransformImplementationRef _Nonnull ref,
    SecTransformStringOrAttributeRef _Nonnull attribute,
    CFTypeRef _Nonnull value
);

Boolean SecTransformRegister (
    CFStringRef uniqueName,
    SecTransformCreateFP createTransformFunction,
    CFErrorRef *error
);

Boolean SecTransformRegister (
    CFStringRef _Nonnull uniqueName,
    SecTransformCreateFP _Nonnull createTransformFunction,
    CFErrorRef  _Nullable * _Nullable error
);

CFErrorRef SecTransformSetAttributeAction (
    SecTransformImplementationRef ref,
    CFStringRef action,
    SecTransformStringOrAttributeRef attribute,
    SecTransformAttributeActionBlock newAction
);

CFErrorRef _Nullable SecTransformSetAttributeAction (
    SecTransformImplementationRef _Nonnull ref,
    CFStringRef _Nonnull action,
    SecTransformStringOrAttributeRef _Nullable attribute,
    SecTransformAttributeActionBlock _Nonnull newAction
);

CFErrorRef SecTransformSetDataAction (
    SecTransformImplementationRef ref,
    CFStringRef action,
    SecTransformDataBlock newAction
);

CFErrorRef _Nullable SecTransformSetDataAction (
    SecTransformImplementationRef _Nonnull ref,
    CFStringRef _Nonnull action,
    SecTransformDataBlock _Nonnull newAction
);

CFErrorRef SecTransformSetTransformAction (
    SecTransformImplementationRef ref,
    CFStringRef action,
    SecTransformActionBlock newAction
);

CFErrorRef _Nullable SecTransformSetTransformAction (
    SecTransformImplementationRef _Nonnull ref,
    CFStringRef _Nonnull action,
    SecTransformActionBlock _Nonnull newAction
);

SecTransformRef SecDecodeTransformCreate (
    CFTypeRef DecodeType,
    CFErrorRef *error
);

SecTransformRef _Nullable SecDecodeTransformCreate (
    CFTypeRef _Nonnull DecodeType,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecDigestTransformCreate (
    CFTypeRef digestType,
    CFIndex digestLength,
    CFErrorRef *error
);

SecTransformRef _Nonnull SecDigestTransformCreate (
    CFTypeRef _Nullable digestType,
    CFIndex digestLength,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecEncodeTransformCreate (
    CFTypeRef encodeType,
    CFErrorRef *error
);

SecTransformRef _Nullable SecEncodeTransformCreate (
    CFTypeRef _Nonnull encodeType,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecDecryptTransformCreate (
    SecKeyRef keyRef,
    CFErrorRef *error
);

SecTransformRef _Nonnull SecDecryptTransformCreate (
    SecKeyRef _Nonnull keyRef,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecEncryptTransformCreate (
    SecKeyRef keyRef,
    CFErrorRef *error
);

SecTransformRef _Nonnull SecEncryptTransformCreate (
    SecKeyRef _Nonnull keyRef,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecIdentityCopyCertificate (
    SecIdentityRef identityRef,
    SecCertificateRef *certificateRef
);

OSStatus SecIdentityCopyCertificate (
    SecIdentityRef _Nonnull identityRef,
    SecCertificateRef  _Nullable * _Nonnull certificateRef
);

OSStatus SecIdentityCopyPreference (
    CFStringRef name,
    CSSM_KEYUSE keyUsage,
    CFArrayRef validIssuers,
    SecIdentityRef *identity
);

OSStatus SecIdentityCopyPreference (
    CFStringRef _Nonnull name,
    CSSM_KEYUSE keyUsage,
    CFArrayRef _Nullable validIssuers,
    SecIdentityRef  _Nullable * _Nonnull identity
);

SecIdentityRef SecIdentityCopyPreferred (
    CFStringRef name,
    CFArrayRef keyUsage,
    CFArrayRef validIssuers
);

SecIdentityRef _Nullable SecIdentityCopyPreferred (
    CFStringRef _Nonnull name,
    CFArrayRef _Nullable keyUsage,
    CFArrayRef _Nullable validIssuers
);

OSStatus SecIdentityCopyPrivateKey (
    SecIdentityRef identityRef,
    SecKeyRef *privateKeyRef
);

OSStatus SecIdentityCopyPrivateKey (
    SecIdentityRef _Nonnull identityRef,
    SecKeyRef  _Nullable * _Nonnull privateKeyRef
);

OSStatus SecIdentityCopySystemIdentity (
    CFStringRef domain,
    SecIdentityRef *idRef,
    CFStringRef *actualDomain
);

OSStatus SecIdentityCopySystemIdentity (
    CFStringRef _Nonnull domain,
    SecIdentityRef  _Nullable * _Nonnull idRef,
    CFStringRef  _Nullable * _Nullable actualDomain
);

OSStatus SecIdentityCreateWithCertificate (
    CFTypeRef keychainOrArray,
    SecCertificateRef certificateRef,
    SecIdentityRef *identityRef
);

OSStatus SecIdentityCreateWithCertificate (
    CFTypeRef _Nullable keychainOrArray,
    SecCertificateRef _Nonnull certificateRef,
    SecIdentityRef  _Nullable * _Nonnull identityRef
);

OSStatus SecIdentitySetPreference (
    SecIdentityRef identity,
    CFStringRef name,
    CSSM_KEYUSE keyUsage
);

OSStatus SecIdentitySetPreference (
    SecIdentityRef _Nonnull identity,
    CFStringRef _Nonnull name,
    CSSM_KEYUSE keyUsage
);

OSStatus SecIdentitySetPreferred (
    SecIdentityRef identity,
    CFStringRef name,
    CFArrayRef keyUsage
);

OSStatus SecIdentitySetPreferred (
    SecIdentityRef _Nullable identity,
    CFStringRef _Nonnull name,
    CFArrayRef _Nullable keyUsage
);

OSStatus SecIdentitySetSystemIdentity (
    CFStringRef domain,
    SecIdentityRef idRef
);

OSStatus SecIdentitySetSystemIdentity (
    CFStringRef _Nonnull domain,
    SecIdentityRef _Nullable idRef
);

OSStatus SecIdentitySearchCopyNext (
    SecIdentitySearchRef searchRef,
    SecIdentityRef *identity
);

OSStatus SecIdentitySearchCopyNext (
    SecIdentitySearchRef _Nonnull searchRef,
    SecIdentityRef  _Nullable * _Nullable identity
);

OSStatus SecIdentitySearchCreate (
    CFTypeRef keychainOrArray,
    CSSM_KEYUSE keyUsage,
    SecIdentitySearchRef *searchRef
);

OSStatus SecIdentitySearchCreate (
    CFTypeRef _Nullable keychainOrArray,
    CSSM_KEYUSE keyUsage,
    SecIdentitySearchRef  _Nullable * _Nullable searchRef
);

OSStatus SecItemExport (
    CFTypeRef secItemOrArray,
    SecExternalFormat outputFormat,
    SecItemImportExportFlags flags,
    const SecItemImportExportKeyParameters *keyParams,
    CFDataRef *exportedData
);

OSStatus SecItemExport (
    CFTypeRef _Nonnull secItemOrArray,
    SecExternalFormat outputFormat,
    SecItemImportExportFlags flags,
    const SecItemImportExportKeyParameters * _Nullable keyParams,
    CFDataRef  _Nullable * _Nonnull exportedData
);

OSStatus SecItemImport (
    CFDataRef importedData,
    CFStringRef fileNameOrExtension,
    SecExternalFormat *inputFormat,
    SecExternalItemType *itemType,
    SecItemImportExportFlags flags,
    const SecItemImportExportKeyParameters *keyParams,
    SecKeychainRef importKeychain,
    CFArrayRef *outItems
);

OSStatus SecItemImport (
    CFDataRef _Nonnull importedData,
    CFStringRef _Nullable fileNameOrExtension,
    SecExternalFormat * _Nullable inputFormat,
    SecExternalItemType * _Nullable itemType,
    SecItemImportExportFlags flags,
    const SecItemImportExportKeyParameters * _Nullable keyParams,
    SecKeychainRef _Nullable importKeychain,
    CFArrayRef  _Nullable * _Nullable outItems
);

OSStatus SecKeychainItemExport (
    CFTypeRef keychainItemOrArray,
    SecExternalFormat outputFormat,
    SecItemImportExportFlags flags,
    const SecKeyImportExportParameters *keyParams,
    CFDataRef *exportedData
);

OSStatus SecKeychainItemExport (
    CFTypeRef _Nonnull keychainItemOrArray,
    SecExternalFormat outputFormat,
    SecItemImportExportFlags flags,
    const SecKeyImportExportParameters * _Nullable keyParams,
    CFDataRef  _Nullable * _Nonnull exportedData
);

OSStatus SecKeychainItemImport (
    CFDataRef importedData,
    CFStringRef fileNameOrExtension,
    SecExternalFormat *inputFormat,
    SecExternalItemType *itemType,
    SecItemImportExportFlags flags,
    const SecKeyImportExportParameters *keyParams,
    SecKeychainRef importKeychain,
    CFArrayRef *outItems
);

OSStatus SecKeychainItemImport (
    CFDataRef _Nonnull importedData,
    CFStringRef _Nullable fileNameOrExtension,
    SecExternalFormat * _Nullable inputFormat,
    SecExternalItemType * _Nullable itemType,
    SecItemImportExportFlags flags,
    const SecKeyImportExportParameters * _Nullable keyParams,
    SecKeychainRef _Nullable importKeychain,
    CFArrayRef  _Nullable * _Nullable outItems
);

OSStatus SecPKCS12Import (
    CFDataRef pkcs12_data,
    CFDictionaryRef options,
    CFArrayRef *items
);

OSStatus SecPKCS12Import (
    CFDataRef _Nonnull pkcs12_data,
    CFDictionaryRef _Nonnull options,
    CFArrayRef  _Nullable * _Nonnull items
);

OSStatus SecItemAdd (
    CFDictionaryRef attributes,
    CFTypeRef *result
);

OSStatus SecItemAdd (
    CFDictionaryRef _Nonnull attributes,
    CFTypeRef  _Nullable * _Nullable result
);

OSStatus SecItemCopyMatching (
    CFDictionaryRef query,
    CFTypeRef *result
);

OSStatus SecItemCopyMatching (
    CFDictionaryRef _Nonnull query,
    CFTypeRef  _Nullable * _Nullable result
);

OSStatus SecItemDelete (
    CFDictionaryRef query
);

OSStatus SecItemDelete (
    CFDictionaryRef _Nonnull query
);

OSStatus SecItemUpdate (
    CFDictionaryRef query,
    CFDictionaryRef attributesToUpdate
);

OSStatus SecItemUpdate (
    CFDictionaryRef _Nonnull query,
    CFDictionaryRef _Nonnull attributesToUpdate
);

SecKeyRef SecKeyCreateFromData (
    CFDictionaryRef parameters,
    CFDataRef keyData,
    CFErrorRef *error
);

SecKeyRef _Nullable SecKeyCreateFromData (
    CFDictionaryRef _Nonnull parameters,
    CFDataRef _Nonnull keyData,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecKeyCreatePair (
    SecKeychainRef keychainRef,
    CSSM_ALGORITHMS algorithm,
    uint32 keySizeInBits,
    CSSM_CC_HANDLE contextHandle,
    CSSM_KEYUSE publicKeyUsage,
    uint32 publicKeyAttr,
    CSSM_KEYUSE privateKeyUsage,
    uint32 privateKeyAttr,
    SecAccessRef initialAccess,
    SecKeyRef *publicKey,
    SecKeyRef *privateKey
);

OSStatus SecKeyCreatePair (
    SecKeychainRef _Nullable keychainRef,
    CSSM_ALGORITHMS algorithm,
    uint32 keySizeInBits,
    CSSM_CC_HANDLE contextHandle,
    CSSM_KEYUSE publicKeyUsage,
    uint32 publicKeyAttr,
    CSSM_KEYUSE privateKeyUsage,
    uint32 privateKeyAttr,
    SecAccessRef _Nullable initialAccess,
    SecKeyRef  _Nullable * _Nullable publicKey,
    SecKeyRef  _Nullable * _Nullable privateKey
);

SecKeyRef SecKeyDeriveFromPassword (
    CFStringRef password,
    CFDictionaryRef parameters,
    CFErrorRef *error
);

SecKeyRef _Nullable SecKeyDeriveFromPassword (
    CFStringRef _Nonnull password,
    CFDictionaryRef _Nonnull parameters,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecKeyGenerate (
    SecKeychainRef keychainRef,
    CSSM_ALGORITHMS algorithm,
    uint32 keySizeInBits,
    CSSM_CC_HANDLE contextHandle,
    CSSM_KEYUSE keyUsage,
    uint32 keyAttr,
    SecAccessRef initialAccess,
    SecKeyRef *keyRef
);

OSStatus SecKeyGenerate (
    SecKeychainRef _Nullable keychainRef,
    CSSM_ALGORITHMS algorithm,
    uint32 keySizeInBits,
    CSSM_CC_HANDLE contextHandle,
    CSSM_KEYUSE keyUsage,
    uint32 keyAttr,
    SecAccessRef _Nullable initialAccess,
    SecKeyRef  _Nullable * _Nullable keyRef
);

OSStatus SecKeyGeneratePair (
    CFDictionaryRef parameters,
    SecKeyRef *publicKey,
    SecKeyRef *privateKey
);

OSStatus SecKeyGeneratePair (
    CFDictionaryRef _Nonnull parameters,
    SecKeyRef  _Nullable * _Nullable publicKey,
    SecKeyRef  _Nullable * _Nullable privateKey
);

void SecKeyGeneratePairAsync (
    CFDictionaryRef parameters,
    dispatch_queue_t deliveryQueue,
    SecKeyGeneratePairBlock result
);

void SecKeyGeneratePairAsync (
    CFDictionaryRef _Nonnull parameters,
    dispatch_queue_t _Nonnull deliveryQueue,
    SecKeyGeneratePairBlock _Nonnull result
);

SecKeyRef SecKeyGenerateSymmetric (
    CFDictionaryRef parameters,
    CFErrorRef *error
);

SecKeyRef _Nullable SecKeyGenerateSymmetric (
    CFDictionaryRef _Nonnull parameters,
    CFErrorRef  _Nullable * _Nullable error
);

size_t SecKeyGetBlockSize (
    SecKeyRef key
);

size_t SecKeyGetBlockSize (
    SecKeyRef _Nonnull key
);

OSStatus SecKeyGetCredentials (
    SecKeyRef keyRef,
    CSSM_ACL_AUTHORIZATION_TAG operation,
    SecCredentialType credentialType,
    const CSSM_ACCESS_CREDENTIALS **outCredentials
);

OSStatus SecKeyGetCredentials (
    SecKeyRef _Nonnull keyRef,
    CSSM_ACL_AUTHORIZATION_TAG operation,
    SecCredentialType credentialType,
    const CSSM_ACCESS_CREDENTIALS * _Nullable * _Nonnull outCredentials
);

OSStatus SecKeyGetCSPHandle (
    SecKeyRef keyRef,
    CSSM_CSP_HANDLE *cspHandle
);

OSStatus SecKeyGetCSPHandle (
    SecKeyRef _Nonnull keyRef,
    CSSM_CSP_HANDLE * _Nonnull cspHandle
);

OSStatus SecKeyGetCSSMKey (
    SecKeyRef key,
    const CSSM_KEY **cssmKey
);

OSStatus SecKeyGetCSSMKey (
    SecKeyRef _Nonnull key,
    const CSSM_KEY * _Nullable * _Nonnull cssmKey
);

SecKeyRef SecKeyUnwrapSymmetric (
    CFDataRef *keyToUnwrap,
    SecKeyRef unwrappingKey,
    CFDictionaryRef parameters,
    CFErrorRef *error
);

SecKeyRef _Nullable SecKeyUnwrapSymmetric (
    CFDataRef  _Nullable * _Nonnull keyToUnwrap,
    SecKeyRef _Nonnull unwrappingKey,
    CFDictionaryRef _Nonnull parameters,
    CFErrorRef  _Nullable * _Nullable error
);

CFDataRef SecKeyWrapSymmetric (
    SecKeyRef keyToWrap,
    SecKeyRef wrappingKey,
    CFDictionaryRef parameters,
    CFErrorRef *error
);

CFDataRef _Nullable SecKeyWrapSymmetric (
    SecKeyRef _Nonnull keyToWrap,
    SecKeyRef _Nonnull wrappingKey,
    CFDictionaryRef _Nonnull parameters,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecKeychainAddCallback (
    SecKeychainCallback callbackFunction,
    SecKeychainEventMask eventMask,
    void *userContext
);

OSStatus SecKeychainAddCallback (
    SecKeychainCallback _Nonnull callbackFunction,
    SecKeychainEventMask eventMask,
    void * _Nullable userContext
);

OSStatus SecKeychainAddGenericPassword (
    SecKeychainRef keychain,
    UInt32 serviceNameLength,
    const char *serviceName,
    UInt32 accountNameLength,
    const char *accountName,
    UInt32 passwordLength,
    const void *passwordData,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainAddGenericPassword (
    SecKeychainRef _Nullable keychain,
    UInt32 serviceNameLength,
    const char * _Nullable serviceName,
    UInt32 accountNameLength,
    const char * _Nullable accountName,
    UInt32 passwordLength,
    const void * _Nonnull passwordData,
    SecKeychainItemRef  _Nullable * _Nullable itemRef
);

OSStatus SecKeychainAddInternetPassword (
    SecKeychainRef keychain,
    UInt32 serverNameLength,
    const char *serverName,
    UInt32 securityDomainLength,
    const char *securityDomain,
    UInt32 accountNameLength,
    const char *accountName,
    UInt32 pathLength,
    const char *path,
    UInt16 port,
    SecProtocolType protocol,
    SecAuthenticationType authenticationType,
    UInt32 passwordLength,
    const void *passwordData,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainAddInternetPassword (
    SecKeychainRef _Nullable keychain,
    UInt32 serverNameLength,
    const char * _Nullable serverName,
    UInt32 securityDomainLength,
    const char * _Nullable securityDomain,
    UInt32 accountNameLength,
    const char * _Nullable accountName,
    UInt32 pathLength,
    const char * _Nullable path,
    UInt16 port,
    SecProtocolType protocol,
    SecAuthenticationType authenticationType,
    UInt32 passwordLength,
    const void * _Nonnull passwordData,
    SecKeychainItemRef  _Nullable * _Nullable itemRef
);

OSStatus SecKeychainAttributeInfoForItemID (
    SecKeychainRef keychain,
    UInt32 itemID,
    SecKeychainAttributeInfo **info
);

OSStatus SecKeychainAttributeInfoForItemID (
    SecKeychainRef _Nullable keychain,
    UInt32 itemID,
    SecKeychainAttributeInfo * _Nullable * _Nonnull info
);

OSStatus SecKeychainCopyAccess (
    SecKeychainRef keychain,
    SecAccessRef *access
);

OSStatus SecKeychainCopyAccess (
    SecKeychainRef _Nullable keychain,
    SecAccessRef  _Nullable * _Nonnull access
);

OSStatus SecKeychainCopyDefault (
    SecKeychainRef *keychain
);

OSStatus SecKeychainCopyDefault (
    SecKeychainRef  _Nullable * _Nonnull keychain
);

OSStatus SecKeychainCopyDomainDefault (
    SecPreferencesDomain domain,
    SecKeychainRef *keychain
);

OSStatus SecKeychainCopyDomainDefault (
    SecPreferencesDomain domain,
    SecKeychainRef  _Nullable * _Nonnull keychain
);

OSStatus SecKeychainCopyDomainSearchList (
    SecPreferencesDomain domain,
    CFArrayRef *searchList
);

OSStatus SecKeychainCopyDomainSearchList (
    SecPreferencesDomain domain,
    CFArrayRef  _Nullable * _Nonnull searchList
);

OSStatus SecKeychainCopySearchList (
    CFArrayRef *searchList
);

OSStatus SecKeychainCopySearchList (
    CFArrayRef  _Nullable * _Nonnull searchList
);

OSStatus SecKeychainCopySettings (
    SecKeychainRef keychain,
    SecKeychainSettings *outSettings
);

OSStatus SecKeychainCopySettings (
    SecKeychainRef _Nullable keychain,
    SecKeychainSettings * _Nonnull outSettings
);

OSStatus SecKeychainCreate (
    const char *pathName,
    UInt32 passwordLength,
    const void *password,
    Boolean promptUser,
    SecAccessRef initialAccess,
    SecKeychainRef *keychain
);

OSStatus SecKeychainCreate (
    const char * _Nonnull pathName,
    UInt32 passwordLength,
    const void * _Nullable password,
    Boolean promptUser,
    SecAccessRef _Nullable initialAccess,
    SecKeychainRef  _Nullable * _Nonnull keychain
);

OSStatus SecKeychainDelete (
    SecKeychainRef keychainOrArray
);

OSStatus SecKeychainDelete (
    SecKeychainRef _Nullable keychainOrArray
);

OSStatus SecKeychainFindGenericPassword (
    CFTypeRef keychainOrArray,
    UInt32 serviceNameLength,
    const char *serviceName,
    UInt32 accountNameLength,
    const char *accountName,
    UInt32 *passwordLength,
    void **passwordData,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainFindGenericPassword (
    CFTypeRef _Nullable keychainOrArray,
    UInt32 serviceNameLength,
    const char * _Nullable serviceName,
    UInt32 accountNameLength,
    const char * _Nullable accountName,
    UInt32 * _Nullable passwordLength,
    void * _Nullable * _Nullable passwordData,
    SecKeychainItemRef  _Nullable * _Nullable itemRef
);

OSStatus SecKeychainFindInternetPassword (
    CFTypeRef keychainOrArray,
    UInt32 serverNameLength,
    const char *serverName,
    UInt32 securityDomainLength,
    const char *securityDomain,
    UInt32 accountNameLength,
    const char *accountName,
    UInt32 pathLength,
    const char *path,
    UInt16 port,
    SecProtocolType protocol,
    SecAuthenticationType authenticationType,
    UInt32 *passwordLength,
    void **passwordData,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainFindInternetPassword (
    CFTypeRef _Nullable keychainOrArray,
    UInt32 serverNameLength,
    const char * _Nullable serverName,
    UInt32 securityDomainLength,
    const char * _Nullable securityDomain,
    UInt32 accountNameLength,
    const char * _Nullable accountName,
    UInt32 pathLength,
    const char * _Nullable path,
    UInt16 port,
    SecProtocolType protocol,
    SecAuthenticationType authenticationType,
    UInt32 * _Nullable passwordLength,
    void * _Nullable * _Nullable passwordData,
    SecKeychainItemRef  _Nullable * _Nullable itemRef
);

OSStatus SecKeychainFreeAttributeInfo (
    SecKeychainAttributeInfo *info
);

OSStatus SecKeychainFreeAttributeInfo (
    SecKeychainAttributeInfo * _Nonnull info
);

OSStatus SecKeychainGetCSPHandle (
    SecKeychainRef keychain,
    CSSM_CSP_HANDLE *cspHandle
);

OSStatus SecKeychainGetCSPHandle (
    SecKeychainRef _Nullable keychain,
    CSSM_CSP_HANDLE * _Nonnull cspHandle
);

OSStatus SecKeychainGetDLDBHandle (
    SecKeychainRef keychain,
    CSSM_DL_DB_HANDLE *dldbHandle
);

OSStatus SecKeychainGetDLDBHandle (
    SecKeychainRef _Nullable keychain,
    CSSM_DL_DB_HANDLE * _Nonnull dldbHandle
);

OSStatus SecKeychainGetPath (
    SecKeychainRef keychain,
    UInt32 *ioPathLength,
    char *pathName
);

OSStatus SecKeychainGetPath (
    SecKeychainRef _Nullable keychain,
    UInt32 * _Nonnull ioPathLength,
    char * _Nonnull pathName
);

OSStatus SecKeychainGetPreferenceDomain (
    SecPreferencesDomain *domain
);

OSStatus SecKeychainGetPreferenceDomain (
    SecPreferencesDomain * _Nonnull domain
);

OSStatus SecKeychainGetStatus (
    SecKeychainRef keychain,
    SecKeychainStatus *keychainStatus
);

OSStatus SecKeychainGetStatus (
    SecKeychainRef _Nullable keychain,
    SecKeychainStatus * _Nonnull keychainStatus
);

OSStatus SecKeychainGetUserInteractionAllowed (
    Boolean *state
);

OSStatus SecKeychainGetUserInteractionAllowed (
    Boolean * _Nonnull state
);

OSStatus SecKeychainGetVersion (
    UInt32 *returnVers
);

OSStatus SecKeychainGetVersion (
    UInt32 * _Nonnull returnVers
);

OSStatus SecKeychainLock (
    SecKeychainRef keychain
);

OSStatus SecKeychainLock (
    SecKeychainRef _Nullable keychain
);

OSStatus SecKeychainOpen (
    const char *pathName,
    SecKeychainRef *keychain
);

OSStatus SecKeychainOpen (
    const char * _Nonnull pathName,
    SecKeychainRef  _Nullable * _Nonnull keychain
);

OSStatus SecKeychainRemoveCallback (
    SecKeychainCallback callbackFunction
);

OSStatus SecKeychainRemoveCallback (
    SecKeychainCallback _Nonnull callbackFunction
);

OSStatus SecKeychainSetAccess (
    SecKeychainRef keychain,
    SecAccessRef access
);

OSStatus SecKeychainSetAccess (
    SecKeychainRef _Nullable keychain,
    SecAccessRef _Nonnull access
);

OSStatus SecKeychainSetDefault (
    SecKeychainRef keychain
);

OSStatus SecKeychainSetDefault (
    SecKeychainRef _Nullable keychain
);

OSStatus SecKeychainSetDomainDefault (
    SecPreferencesDomain domain,
    SecKeychainRef keychain
);

OSStatus SecKeychainSetDomainDefault (
    SecPreferencesDomain domain,
    SecKeychainRef _Nullable keychain
);

OSStatus SecKeychainSetDomainSearchList (
    SecPreferencesDomain domain,
    CFArrayRef searchList
);

OSStatus SecKeychainSetDomainSearchList (
    SecPreferencesDomain domain,
    CFArrayRef _Nonnull searchList
);

OSStatus SecKeychainSetSearchList (
    CFArrayRef searchList
);

OSStatus SecKeychainSetSearchList (
    CFArrayRef _Nonnull searchList
);

OSStatus SecKeychainSetSettings (
    SecKeychainRef keychain,
    const SecKeychainSettings *newSettings
);

OSStatus SecKeychainSetSettings (
    SecKeychainRef _Nullable keychain,
    const SecKeychainSettings * _Nonnull newSettings
);

OSStatus SecKeychainUnlock (
    SecKeychainRef keychain,
    UInt32 passwordLength,
    const void *password,
    Boolean usePassword
);

OSStatus SecKeychainUnlock (
    SecKeychainRef _Nullable keychain,
    UInt32 passwordLength,
    const void * _Nullable password,
    Boolean usePassword
);

OSStatus SecKeychainItemCopyAccess (
    SecKeychainItemRef itemRef,
    SecAccessRef *access
);

OSStatus SecKeychainItemCopyAccess (
    SecKeychainItemRef _Nonnull itemRef,
    SecAccessRef  _Nullable * _Nonnull access
);

OSStatus SecKeychainItemCopyAttributesAndData (
    SecKeychainItemRef itemRef,
    SecKeychainAttributeInfo *info,
    SecItemClass *itemClass,
    SecKeychainAttributeList **attrList,
    UInt32 *length,
    void **outData
);

OSStatus SecKeychainItemCopyAttributesAndData (
    SecKeychainItemRef _Nonnull itemRef,
    SecKeychainAttributeInfo * _Nullable info,
    SecItemClass * _Nullable itemClass,
    SecKeychainAttributeList * _Nullable * _Nullable attrList,
    UInt32 * _Nullable length,
    void * _Nullable * _Nullable outData
);

OSStatus SecKeychainItemCopyContent (
    SecKeychainItemRef itemRef,
    SecItemClass *itemClass,
    SecKeychainAttributeList *attrList,
    UInt32 *length,
    void **outData
);

OSStatus SecKeychainItemCopyContent (
    SecKeychainItemRef _Nonnull itemRef,
    SecItemClass * _Nullable itemClass,
    SecKeychainAttributeList * _Nullable attrList,
    UInt32 * _Nullable length,
    void * _Nullable * _Nullable outData
);

OSStatus SecKeychainItemCopyFromPersistentReference (
    CFDataRef persistentItemRef,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainItemCopyFromPersistentReference (
    CFDataRef _Nonnull persistentItemRef,
    SecKeychainItemRef  _Nullable * _Nonnull itemRef
);

OSStatus SecKeychainItemCopyKeychain (
    SecKeychainItemRef itemRef,
    SecKeychainRef *keychainRef
);

OSStatus SecKeychainItemCopyKeychain (
    SecKeychainItemRef _Nonnull itemRef,
    SecKeychainRef  _Nullable * _Nonnull keychainRef
);

OSStatus SecKeychainItemCreateCopy (
    SecKeychainItemRef itemRef,
    SecKeychainRef destKeychainRef,
    SecAccessRef initialAccess,
    SecKeychainItemRef *itemCopy
);

OSStatus SecKeychainItemCreateCopy (
    SecKeychainItemRef _Nonnull itemRef,
    SecKeychainRef _Nullable destKeychainRef,
    SecAccessRef _Nonnull initialAccess,
    SecKeychainItemRef  _Nullable * _Nonnull itemCopy
);

OSStatus SecKeychainItemCreateFromContent (
    SecItemClass itemClass,
    SecKeychainAttributeList *attrList,
    UInt32 length,
    const void *data,
    SecKeychainRef keychainRef,
    SecAccessRef initialAccess,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainItemCreateFromContent (
    SecItemClass itemClass,
    SecKeychainAttributeList * _Nonnull attrList,
    UInt32 length,
    const void * _Nullable data,
    SecKeychainRef _Nullable keychainRef,
    SecAccessRef _Nullable initialAccess,
    SecKeychainItemRef  _Nullable * _Nullable itemRef
);

OSStatus SecKeychainItemCreatePersistentReference (
    SecKeychainItemRef itemRef,
    CFDataRef *persistentItemRef
);

OSStatus SecKeychainItemCreatePersistentReference (
    SecKeychainItemRef _Nonnull itemRef,
    CFDataRef  _Nullable * _Nonnull persistentItemRef
);

OSStatus SecKeychainItemDelete (
    SecKeychainItemRef itemRef
);

OSStatus SecKeychainItemDelete (
    SecKeychainItemRef _Nonnull itemRef
);

OSStatus SecKeychainItemFreeAttributesAndData (
    SecKeychainAttributeList *attrList,
    void *data
);

OSStatus SecKeychainItemFreeAttributesAndData (
    SecKeychainAttributeList * _Nullable attrList,
    void * _Nullable data
);

OSStatus SecKeychainItemFreeContent (
    SecKeychainAttributeList *attrList,
    void *data
);

OSStatus SecKeychainItemFreeContent (
    SecKeychainAttributeList * _Nullable attrList,
    void * _Nullable data
);

OSStatus SecKeychainItemGetDLDBHandle (
    SecKeychainItemRef keyItemRef,
    CSSM_DL_DB_HANDLE *dldbHandle
);

OSStatus SecKeychainItemGetDLDBHandle (
    SecKeychainItemRef _Nonnull keyItemRef,
    CSSM_DL_DB_HANDLE * _Nonnull dldbHandle
);

OSStatus SecKeychainItemGetUniqueRecordID (
    SecKeychainItemRef itemRef,
    const CSSM_DB_UNIQUE_RECORD **uniqueRecordID
);

OSStatus SecKeychainItemGetUniqueRecordID (
    SecKeychainItemRef _Nonnull itemRef,
    const CSSM_DB_UNIQUE_RECORD * _Nullable * _Nonnull uniqueRecordID
);

OSStatus SecKeychainItemModifyAttributesAndData (
    SecKeychainItemRef itemRef,
    const SecKeychainAttributeList *attrList,
    UInt32 length,
    const void *data
);

OSStatus SecKeychainItemModifyAttributesAndData (
    SecKeychainItemRef _Nonnull itemRef,
    const SecKeychainAttributeList * _Nullable attrList,
    UInt32 length,
    const void * _Nullable data
);

OSStatus SecKeychainItemModifyContent (
    SecKeychainItemRef itemRef,
    const SecKeychainAttributeList *attrList,
    UInt32 length,
    const void *data
);

OSStatus SecKeychainItemModifyContent (
    SecKeychainItemRef _Nonnull itemRef,
    const SecKeychainAttributeList * _Nullable attrList,
    UInt32 length,
    const void * _Nullable data
);

OSStatus SecKeychainItemSetAccess (
    SecKeychainItemRef itemRef,
    SecAccessRef access
);

OSStatus SecKeychainItemSetAccess (
    SecKeychainItemRef _Nonnull itemRef,
    SecAccessRef _Nonnull access
);

OSStatus SecKeychainSearchCopyNext (
    SecKeychainSearchRef searchRef,
    SecKeychainItemRef *itemRef
);

OSStatus SecKeychainSearchCopyNext (
    SecKeychainSearchRef _Nonnull searchRef,
    SecKeychainItemRef  _Nullable * _Nonnull itemRef
);

OSStatus SecKeychainSearchCreateFromAttributes (
    CFTypeRef keychainOrArray,
    SecItemClass itemClass,
    const SecKeychainAttributeList *attrList,
    SecKeychainSearchRef *searchRef
);

OSStatus SecKeychainSearchCreateFromAttributes (
    CFTypeRef _Nullable keychainOrArray,
    SecItemClass itemClass,
    const SecKeychainAttributeList * _Nullable attrList,
    SecKeychainSearchRef  _Nullable * _Nonnull searchRef
);

CFDictionaryRef SecPolicyCopyProperties (
    SecPolicyRef policyRef
);

CFDictionaryRef _Nonnull SecPolicyCopyProperties (
    SecPolicyRef _Nonnull policyRef
);

SecPolicyRef SecPolicyCreateBasicX509 (
    void
);

SecPolicyRef _Nonnull SecPolicyCreateBasicX509 (
    void
);

SecPolicyRef SecPolicyCreateRevocation (
    CFOptionFlags revocationFlags
);

SecPolicyRef _Nonnull SecPolicyCreateRevocation (
    CFOptionFlags revocationFlags
);

SecPolicyRef SecPolicyCreateSSL (
    Boolean server,
    CFStringRef hostname
);

SecPolicyRef _Nonnull SecPolicyCreateSSL (
    Boolean server,
    CFStringRef _Nullable hostname
);

SecPolicyRef SecPolicyCreateWithOID (
    CFTypeRef policyOID
);

SecPolicyRef _Nullable SecPolicyCreateWithOID (
    CFTypeRef _Nonnull policyOID
);

SecPolicyRef SecPolicyCreateWithProperties (
    CFTypeRef policyIdentifier,
    CFDictionaryRef properties
);

SecPolicyRef _Nullable SecPolicyCreateWithProperties (
    CFTypeRef _Nonnull policyIdentifier,
    CFDictionaryRef _Nullable properties
);

OSStatus SecPolicyGetOID (
    SecPolicyRef policyRef,
    CSSM_OID *oid
);

OSStatus SecPolicyGetOID (
    SecPolicyRef _Nonnull policyRef,
    CSSM_OID * _Nonnull oid
);

OSStatus SecPolicyGetTPHandle (
    SecPolicyRef policyRef,
    CSSM_TP_HANDLE *tpHandle
);

OSStatus SecPolicyGetTPHandle (
    SecPolicyRef _Nonnull policyRef,
    CSSM_TP_HANDLE * _Nonnull tpHandle
);

OSStatus SecPolicyGetValue (
    SecPolicyRef policyRef,
    CSSM_DATA *value
);

OSStatus SecPolicyGetValue (
    SecPolicyRef _Nonnull policyRef,
    CSSM_DATA * _Nonnull value
);

OSStatus SecPolicySetProperties (
    SecPolicyRef policyRef,
    CFDictionaryRef properties
);

OSStatus SecPolicySetProperties (
    SecPolicyRef _Nonnull policyRef,
    CFDictionaryRef _Nonnull properties
);

OSStatus SecPolicySetValue (
    SecPolicyRef policyRef,
    const CSSM_DATA *value
);

OSStatus SecPolicySetValue (
    SecPolicyRef _Nonnull policyRef,
    const CSSM_DATA * _Nonnull value
);

OSStatus SecPolicySearchCopyNext (
    SecPolicySearchRef searchRef,
    SecPolicyRef *policyRef
);

OSStatus SecPolicySearchCopyNext (
    SecPolicySearchRef _Nonnull searchRef,
    SecPolicyRef  _Nullable * _Nonnull policyRef
);

OSStatus SecPolicySearchCreate (
    CSSM_CERT_TYPE certType,
    const CSSM_OID *policyOID,
    const CSSM_DATA *value,
    SecPolicySearchRef *searchRef
);

OSStatus SecPolicySearchCreate (
    CSSM_CERT_TYPE certType,
    const CSSM_OID * _Nonnull policyOID,
    const CSSM_DATA * _Nullable value,
    SecPolicySearchRef  _Nullable * _Nonnull searchRef
);

int SecRandomCopyBytes (
    SecRandomRef rnd,
    size_t count,
    uint8_t *bytes
);

int SecRandomCopyBytes (
    SecRandomRef _Nullable rnd,
    size_t count,
    uint8_t * _Nonnull bytes
);

OSStatus SecRequirementCopyData (
    SecRequirementRef requirement,
    SecCSFlags flags,
    CFDataRef *data
);

OSStatus SecRequirementCopyData (
    SecRequirementRef _Nonnull requirement,
    SecCSFlags flags,
    CFDataRef  _Nullable * _Nonnull data
);

OSStatus SecRequirementCopyString (
    SecRequirementRef requirement,
    SecCSFlags flags,
    CFStringRef *text
);

OSStatus SecRequirementCopyString (
    SecRequirementRef _Nonnull requirement,
    SecCSFlags flags,
    CFStringRef  _Nullable * _Nonnull text
);

OSStatus SecRequirementCreateWithData (
    CFDataRef data,
    SecCSFlags flags,
    SecRequirementRef *requirement
);

OSStatus SecRequirementCreateWithData (
    CFDataRef _Nonnull data,
    SecCSFlags flags,
    SecRequirementRef  _Nullable * _Nonnull requirement
);

OSStatus SecRequirementCreateWithString (
    CFStringRef text,
    SecCSFlags flags,
    SecRequirementRef *requirement
);

OSStatus SecRequirementCreateWithString (
    CFStringRef _Nonnull text,
    SecCSFlags flags,
    SecRequirementRef  _Nullable * _Nonnull requirement
);

OSStatus SecRequirementCreateWithStringAndErrors (
    CFStringRef text,
    SecCSFlags flags,
    CFErrorRef *errors,
    SecRequirementRef *requirement
);

OSStatus SecRequirementCreateWithStringAndErrors (
    CFStringRef _Nonnull text,
    SecCSFlags flags,
    CFErrorRef  _Nullable * _Nullable errors,
    SecRequirementRef  _Nullable * _Nonnull requirement
);

SecTransformRef SecSignTransformCreate (
    SecKeyRef key,
    CFErrorRef *error
);

SecTransformRef _Nullable SecSignTransformCreate (
    SecKeyRef _Nonnull key,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecVerifyTransformCreate (
    SecKeyRef key,
    CFDataRef signature,
    CFErrorRef *error
);

SecTransformRef _Nullable SecVerifyTransformCreate (
    SecKeyRef _Nonnull key,
    CFDataRef _Nullable signature,
    CFErrorRef  _Nullable * _Nullable error
);

OSStatus SecStaticCodeCheckValidity (
    SecStaticCodeRef staticCode,
    SecCSFlags flags,
    SecRequirementRef requirement
);

OSStatus SecStaticCodeCheckValidity (
    SecStaticCodeRef _Nonnull staticCode,
    SecCSFlags flags,
    SecRequirementRef _Nullable requirement
);

OSStatus SecStaticCodeCheckValidityWithErrors (
    SecStaticCodeRef staticCode,
    SecCSFlags flags,
    SecRequirementRef requirement,
    CFErrorRef *errors
);

OSStatus SecStaticCodeCheckValidityWithErrors (
    SecStaticCodeRef _Nonnull staticCode,
    SecCSFlags flags,
    SecRequirementRef _Nullable requirement,
    CFErrorRef  _Nullable * _Nullable errors
);

OSStatus SecStaticCodeCreateWithPath (
    CFURLRef path,
    SecCSFlags flags,
    SecStaticCodeRef *staticCode
);

OSStatus SecStaticCodeCreateWithPath (
    CFURLRef _Nonnull path,
    SecCSFlags flags,
    SecStaticCodeRef  _Nullable * _Nonnull staticCode
);

OSStatus SecStaticCodeCreateWithPathAndAttributes (
    CFURLRef path,
    SecCSFlags flags,
    CFDictionaryRef attributes,
    SecStaticCodeRef *staticCode
);

OSStatus SecStaticCodeCreateWithPathAndAttributes (
    CFURLRef _Nonnull path,
    SecCSFlags flags,
    CFDictionaryRef _Nonnull attributes,
    SecStaticCodeRef  _Nullable * _Nonnull staticCode
);

CFTypeRef SecTaskCopyValueForEntitlement (
    SecTaskRef task,
    CFStringRef entitlement,
    CFErrorRef *error
);

CFTypeRef _Nullable SecTaskCopyValueForEntitlement (
    SecTaskRef _Nonnull task,
    CFStringRef _Nonnull entitlement,
    CFErrorRef  _Nullable * _Nullable error
);

CFDictionaryRef SecTaskCopyValuesForEntitlements (
    SecTaskRef task,
    CFArrayRef entitlements,
    CFErrorRef *error
);

CFDictionaryRef _Nullable SecTaskCopyValuesForEntitlements (
    SecTaskRef _Nonnull task,
    CFArrayRef _Nonnull entitlements,
    CFErrorRef  _Nullable * _Nullable error
);

SecTaskRef SecTaskCreateFromSelf (
    CFAllocatorRef allocator
);

SecTaskRef _Nullable SecTaskCreateFromSelf (
    CFAllocatorRef _Nullable allocator
);

SecTaskRef SecTaskCreateWithAuditToken (
    CFAllocatorRef allocator,
    audit_token_t token
);

SecTaskRef _Nullable SecTaskCreateWithAuditToken (
    CFAllocatorRef _Nullable allocator,
    audit_token_t token
);

SecGroupTransformRef SecTransformConnectTransforms (
    SecTransformRef sourceTransformRef,
    CFStringRef sourceAttributeName,
    SecTransformRef destinationTransformRef,
    CFStringRef destinationAttributeName,
    SecGroupTransformRef group,
    CFErrorRef *error
);

SecGroupTransformRef _Nullable SecTransformConnectTransforms (
    SecTransformRef _Nonnull sourceTransformRef,
    CFStringRef _Nonnull sourceAttributeName,
    SecTransformRef _Nonnull destinationTransformRef,
    CFStringRef _Nonnull destinationAttributeName,
    SecGroupTransformRef _Nonnull group,
    CFErrorRef  _Nullable * _Nullable error
);

CFDictionaryRef SecTransformCopyExternalRepresentation (
    SecTransformRef transformRef
);

CFDictionaryRef _Nonnull SecTransformCopyExternalRepresentation (
    SecTransformRef _Nonnull transformRef
);

SecTransformRef SecTransformCreateFromExternalRepresentation (
    CFDictionaryRef dictionary,
    CFErrorRef *error
);

SecTransformRef _Nullable SecTransformCreateFromExternalRepresentation (
    CFDictionaryRef _Nonnull dictionary,
    CFErrorRef  _Nullable * _Nullable error
);

SecGroupTransformRef SecTransformCreateGroupTransform (
    void
);

SecGroupTransformRef _Nonnull SecTransformCreateGroupTransform (
    void
);

CFTypeRef SecTransformExecute (
    SecTransformRef transformRef,
    CFErrorRef *errorRef
);

CFTypeRef _Nonnull SecTransformExecute (
    SecTransformRef _Nonnull transformRef,
    CFErrorRef  _Nullable * _Nullable errorRef
);

void SecTransformExecuteAsync (
    SecTransformRef transformRef,
    dispatch_queue_t deliveryQueue,
    SecMessageBlock deliveryBlock
);

void SecTransformExecuteAsync (
    SecTransformRef _Nonnull transformRef,
    dispatch_queue_t _Nonnull deliveryQueue,
    SecMessageBlock _Nonnull deliveryBlock
);

SecTransformRef SecTransformFindByName (
    SecGroupTransformRef transform,
    CFStringRef name
);

SecTransformRef _Nullable SecTransformFindByName (
    SecGroupTransformRef _Nonnull transform,
    CFStringRef _Nonnull name
);

CFTypeRef SecTransformGetAttribute (
    SecTransformRef transformRef,
    CFStringRef key
);

CFTypeRef _Nullable SecTransformGetAttribute (
    SecTransformRef _Nonnull transformRef,
    CFStringRef _Nonnull key
);

Boolean SecTransformSetAttribute (
    SecTransformRef transformRef,
    CFStringRef key,
    CFTypeRef value,
    CFErrorRef *error
);

Boolean SecTransformSetAttribute (
    SecTransformRef _Nonnull transformRef,
    CFStringRef _Nonnull key,
    CFTypeRef _Nonnull value,
    CFErrorRef  _Nullable * _Nullable error
);

SecTransformRef SecTransformCreateReadTransformWithReadStream (
    CFReadStreamRef inputStream
);

SecTransformRef _Nonnull SecTransformCreateReadTransformWithReadStream (
    CFReadStreamRef _Nonnull inputStream
);

OSStatus SecTrustCopyAnchorCertificates (
    CFArrayRef *anchors
);

OSStatus SecTrustCopyAnchorCertificates (
    CFArrayRef  _Nullable * _Nonnull anchors
);

OSStatus SecTrustCopyCustomAnchorCertificates (
    SecTrustRef trust,
    CFArrayRef *anchors
);

OSStatus SecTrustCopyCustomAnchorCertificates (
    SecTrustRef _Nonnull trust,
    CFArrayRef  _Nullable * _Nonnull anchors
);

CFDataRef SecTrustCopyExceptions (
    SecTrustRef trust
);

CFDataRef _Nonnull SecTrustCopyExceptions (
    SecTrustRef _Nonnull trust
);

OSStatus SecTrustCopyPolicies (
    SecTrustRef trust,
    CFArrayRef *policies
);

OSStatus SecTrustCopyPolicies (
    SecTrustRef _Nonnull trust,
    CFArrayRef  _Nullable * _Nonnull policies
);

CFArrayRef SecTrustCopyProperties (
    SecTrustRef trust
);

CFArrayRef _Nullable SecTrustCopyProperties (
    SecTrustRef _Nonnull trust
);

SecKeyRef SecTrustCopyPublicKey (
    SecTrustRef trust
);

SecKeyRef _Nullable SecTrustCopyPublicKey (
    SecTrustRef _Nonnull trust
);

CFDictionaryRef SecTrustCopyResult (
    SecTrustRef trust
);

CFDictionaryRef _Nullable SecTrustCopyResult (
    SecTrustRef _Nonnull trust
);

OSStatus SecTrustCreateWithCertificates (
    CFTypeRef certificates,
    CFTypeRef policies,
    SecTrustRef *trust
);

OSStatus SecTrustCreateWithCertificates (
    CFTypeRef _Nonnull certificates,
    CFTypeRef _Nullable policies,
    SecTrustRef  _Nullable * _Nonnull trust
);

OSStatus SecTrustEvaluate (
    SecTrustRef trust,
    SecTrustResultType *result
);

OSStatus SecTrustEvaluate (
    SecTrustRef _Nonnull trust,
    SecTrustResultType * _Nullable result
);

OSStatus SecTrustEvaluateAsync (
    SecTrustRef trust,
    dispatch_queue_t queue,
    SecTrustCallback result
);

OSStatus SecTrustEvaluateAsync (
    SecTrustRef _Nonnull trust,
    dispatch_queue_t _Nullable queue,
    SecTrustCallback _Nonnull result
);

SecCertificateRef SecTrustGetCertificateAtIndex (
    SecTrustRef trust,
    CFIndex ix
);

SecCertificateRef _Nullable SecTrustGetCertificateAtIndex (
    SecTrustRef _Nonnull trust,
    CFIndex ix
);

CFIndex SecTrustGetCertificateCount (
    SecTrustRef trust
);

CFIndex SecTrustGetCertificateCount (
    SecTrustRef _Nonnull trust
);

OSStatus SecTrustGetCssmResult (
    SecTrustRef trust,
    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR *result
);

OSStatus SecTrustGetCssmResult (
    SecTrustRef _Nonnull trust,
    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR  _Nullable * _Nonnull result
);

OSStatus SecTrustGetCssmResultCode (
    SecTrustRef trust,
    OSStatus *resultCode
);

OSStatus SecTrustGetCssmResultCode (
    SecTrustRef _Nonnull trust,
    OSStatus * _Nonnull resultCode
);

OSStatus SecTrustGetNetworkFetchAllowed (
    SecTrustRef trust,
    Boolean *allowFetch
);

OSStatus SecTrustGetNetworkFetchAllowed (
    SecTrustRef _Nonnull trust,
    Boolean * _Nonnull allowFetch
);

OSStatus SecTrustGetResult (
    SecTrustRef trustRef,
    SecTrustResultType *result,
    CFArrayRef *certChain,
    CSSM_TP_APPLE_EVIDENCE_INFO **statusChain
);

OSStatus SecTrustGetResult (
    SecTrustRef _Nonnull trustRef,
    SecTrustResultType * _Nullable result,
    CFArrayRef  _Nullable * _Nonnull certChain,
    CSSM_TP_APPLE_EVIDENCE_INFO * _Nullable * _Nonnull statusChain
);

OSStatus SecTrustGetTPHandle (
    SecTrustRef trust,
    CSSM_TP_HANDLE *handle
);

OSStatus SecTrustGetTPHandle (
    SecTrustRef _Nonnull trust,
    CSSM_TP_HANDLE * _Nonnull handle
);

OSStatus SecTrustGetTrustResult (
    SecTrustRef trust,
    SecTrustResultType *result
);

OSStatus SecTrustGetTrustResult (
    SecTrustRef _Nonnull trust,
    SecTrustResultType * _Nonnull result
);

CFAbsoluteTime SecTrustGetVerifyTime (
    SecTrustRef trust
);

CFAbsoluteTime SecTrustGetVerifyTime (
    SecTrustRef _Nonnull trust
);

OSStatus SecTrustSetAnchorCertificates (
    SecTrustRef trust,
    CFArrayRef anchorCertificates
);

OSStatus SecTrustSetAnchorCertificates (
    SecTrustRef _Nonnull trust,
    CFArrayRef _Nonnull anchorCertificates
);

OSStatus SecTrustSetAnchorCertificatesOnly (
    SecTrustRef trust,
    Boolean anchorCertificatesOnly
);

OSStatus SecTrustSetAnchorCertificatesOnly (
    SecTrustRef _Nonnull trust,
    Boolean anchorCertificatesOnly
);

bool SecTrustSetExceptions (
    SecTrustRef trust,
    CFDataRef exceptions
);

bool SecTrustSetExceptions (
    SecTrustRef _Nonnull trust,
    CFDataRef _Nonnull exceptions
);

OSStatus SecTrustSetKeychains (
    SecTrustRef trust,
    CFTypeRef keychainOrArray
);

OSStatus SecTrustSetKeychains (
    SecTrustRef _Nonnull trust,
    CFTypeRef _Nullable keychainOrArray
);

OSStatus SecTrustSetNetworkFetchAllowed (
    SecTrustRef trust,
    Boolean allowFetch
);

OSStatus SecTrustSetNetworkFetchAllowed (
    SecTrustRef _Nonnull trust,
    Boolean allowFetch
);

OSStatus SecTrustSetOCSPResponse (
    SecTrustRef trust,
    CFTypeRef responseData
);

OSStatus SecTrustSetOCSPResponse (
    SecTrustRef _Nonnull trust,
    CFTypeRef _Nullable responseData
);

OSStatus SecTrustSetOptions (
    SecTrustRef trustRef,
    SecTrustOptionFlags options
);

OSStatus SecTrustSetOptions (
    SecTrustRef _Nonnull trustRef,
    SecTrustOptionFlags options
);

OSStatus SecTrustSetParameters (
    SecTrustRef trustRef,
    CSSM_TP_ACTION action,
    CFDataRef actionData
);

OSStatus SecTrustSetParameters (
    SecTrustRef _Nonnull trustRef,
    CSSM_TP_ACTION action,
    CFDataRef _Nonnull actionData
);

OSStatus SecTrustSetPolicies (
    SecTrustRef trust,
    CFTypeRef policies
);

OSStatus SecTrustSetPolicies (
    SecTrustRef _Nonnull trust,
    CFTypeRef _Nonnull policies
);

OSStatus SecTrustSetVerifyDate (
    SecTrustRef trust,
    CFDateRef verifyDate
);

OSStatus SecTrustSetVerifyDate (
    SecTrustRef _Nonnull trust,
    CFDateRef _Nonnull verifyDate
);

OSStatus SecTrustedApplicationCopyData (
    SecTrustedApplicationRef appRef,
    CFDataRef *data
);

OSStatus SecTrustedApplicationCopyData (
    SecTrustedApplicationRef _Nonnull appRef,
    CFDataRef  _Nullable * _Nonnull data
);

OSStatus SecTrustedApplicationCreateFromPath (
    const char *path,
    SecTrustedApplicationRef *app
);

OSStatus SecTrustedApplicationCreateFromPath (
    const char * _Nullable path,
    SecTrustedApplicationRef  _Nullable * _Nonnull app
);

OSStatus SecTrustedApplicationSetData (
    SecTrustedApplicationRef appRef,
    CFDataRef data
);

OSStatus SecTrustedApplicationSetData (
    SecTrustedApplicationRef _Nonnull appRef,
    CFDataRef _Nonnull data
);

OSStatus SecTrustSettingsCopyCertificates (
    SecTrustSettingsDomain domain,
    CFArrayRef *certArray
);

OSStatus SecTrustSettingsCopyCertificates (
    SecTrustSettingsDomain domain,
    CFArrayRef  _Nullable * _Nullable certArray
);

OSStatus SecTrustSettingsCopyModificationDate (
    SecCertificateRef certRef,
    SecTrustSettingsDomain domain,
    CFDateRef *modificationDate
);

OSStatus SecTrustSettingsCopyModificationDate (
    SecCertificateRef _Nonnull certRef,
    SecTrustSettingsDomain domain,
    CFDateRef  _Nullable * _Nonnull modificationDate
);

OSStatus SecTrustSettingsCopyTrustSettings (
    SecCertificateRef certRef,
    SecTrustSettingsDomain domain,
    CFArrayRef *trustSettings
);

OSStatus SecTrustSettingsCopyTrustSettings (
    SecCertificateRef _Nonnull certRef,
    SecTrustSettingsDomain domain,
    CFArrayRef  _Nullable * _Nonnull trustSettings
);

OSStatus SecTrustSettingsCreateExternalRepresentation (
    SecTrustSettingsDomain domain,
    CFDataRef *trustSettings
);

OSStatus SecTrustSettingsCreateExternalRepresentation (
    SecTrustSettingsDomain domain,
    CFDataRef  _Nullable * _Nonnull trustSettings
);

OSStatus SecTrustSettingsImportExternalRepresentation (
    SecTrustSettingsDomain domain,
    CFDataRef trustSettings
);

OSStatus SecTrustSettingsImportExternalRepresentation (
    SecTrustSettingsDomain domain,
    CFDataRef _Nonnull trustSettings
);

OSStatus SecTrustSettingsRemoveTrustSettings (
    SecCertificateRef certRef,
    SecTrustSettingsDomain domain
);

OSStatus SecTrustSettingsRemoveTrustSettings (
    SecCertificateRef _Nonnull certRef,
    SecTrustSettingsDomain domain
);

OSStatus SecTrustSettingsSetTrustSettings (
    SecCertificateRef certRef,
    SecTrustSettingsDomain domain,
    CFTypeRef trustSettingsDictOrArray
);

OSStatus SecTrustSettingsSetTrustSettings (
    SecCertificateRef _Nonnull certRef,
    SecTrustSettingsDomain domain,
    CFTypeRef _Nullable trustSettingsDictOrArray
);

OSStatus SSLAddDistinguishedName (
    SSLContextRef context,
    const void *derDN,
    size_t derDNLen
);

OSStatus SSLAddDistinguishedName (
    SSLContextRef _Nonnull context,
    const void * _Nullable derDN,
    size_t derDNLen
);

OSStatus SSLClose (
    SSLContextRef context
);

OSStatus SSLClose (
    SSLContextRef _Nonnull context
);

OSStatus SSLCopyCertificateAuthorities (
    SSLContextRef context,
    CFArrayRef *certificates
);

OSStatus SSLCopyCertificateAuthorities (
    SSLContextRef _Nonnull context,
    CFArrayRef  _Nullable * _Nonnull certificates
);

OSStatus SSLCopyDistinguishedNames (
    SSLContextRef context,
    CFArrayRef *names
);

OSStatus SSLCopyDistinguishedNames (
    SSLContextRef _Nonnull context,
    CFArrayRef  _Nullable * _Nonnull names
);

OSStatus SSLCopyPeerCertificates (
    SSLContextRef context,
    CFArrayRef *certs
);

OSStatus SSLCopyPeerCertificates (
    SSLContextRef _Nonnull context,
    CFArrayRef  _Nullable * _Nonnull certs
);

OSStatus SSLCopyPeerTrust (
    SSLContextRef context,
    SecTrustRef *trust
);

OSStatus SSLCopyPeerTrust (
    SSLContextRef _Nonnull context,
    SecTrustRef  _Nullable * _Nonnull trust
);

OSStatus SSLCopyTrustedRoots (
    SSLContextRef context,
    CFArrayRef *trustedRoots
);

OSStatus SSLCopyTrustedRoots (
    SSLContextRef _Nonnull context,
    CFArrayRef  _Nullable * _Nonnull trustedRoots
);

SSLContextRef SSLCreateContext (
    CFAllocatorRef alloc,
    SSLProtocolSide protocolSide,
    SSLConnectionType connectionType
);

SSLContextRef _Nullable SSLCreateContext (
    CFAllocatorRef _Nullable alloc,
    SSLProtocolSide protocolSide,
    SSLConnectionType connectionType
);

OSStatus SSLDisposeContext (
    SSLContextRef context
);

OSStatus SSLDisposeContext (
    SSLContextRef _Nonnull context
);

OSStatus SSLGetAllowsAnyRoot (
    SSLContextRef context,
    Boolean *anyRoot
);

OSStatus SSLGetAllowsAnyRoot (
    SSLContextRef _Nonnull context,
    Boolean * _Nonnull anyRoot
);

OSStatus SSLGetAllowsExpiredCerts (
    SSLContextRef context,
    Boolean *allowsExpired
);

OSStatus SSLGetAllowsExpiredCerts (
    SSLContextRef _Nonnull context,
    Boolean * _Nonnull allowsExpired
);

OSStatus SSLGetAllowsExpiredRoots (
    SSLContextRef context,
    Boolean *allowsExpired
);

OSStatus SSLGetAllowsExpiredRoots (
    SSLContextRef _Nonnull context,
    Boolean * _Nonnull allowsExpired
);

OSStatus SSLGetBufferedReadSize (
    SSLContextRef context,
    size_t *bufSize
);

OSStatus SSLGetBufferedReadSize (
    SSLContextRef _Nonnull context,
    size_t * _Nonnull bufSize
);

OSStatus SSLGetClientCertificateState (
    SSLContextRef context,
    SSLClientCertificateState *clientState
);

OSStatus SSLGetClientCertificateState (
    SSLContextRef _Nonnull context,
    SSLClientCertificateState * _Nonnull clientState
);

OSStatus SSLGetConnection (
    SSLContextRef context,
    SSLConnectionRef *connection
);

OSStatus SSLGetConnection (
    SSLContextRef _Nonnull context,
    SSLConnectionRef  _Nullable * _Nonnull connection
);

OSStatus SSLGetDatagramWriteSize (
    SSLContextRef dtlsContext,
    size_t *bufSize
);

OSStatus SSLGetDatagramWriteSize (
    SSLContextRef _Nonnull dtlsContext,
    size_t * _Nonnull bufSize
);

OSStatus SSLGetDiffieHellmanParams (
    SSLContextRef context,
    const void **dhParams,
    size_t *dhParamsLen
);

OSStatus SSLGetDiffieHellmanParams (
    SSLContextRef _Nonnull context,
    const void * _Nullable * _Nonnull dhParams,
    size_t * _Nonnull dhParamsLen
);

OSStatus SSLGetEnableCertVerify (
    SSLContextRef context,
    Boolean *enableVerify
);

OSStatus SSLGetEnableCertVerify (
    SSLContextRef _Nonnull context,
    Boolean * _Nonnull enableVerify
);

OSStatus SSLGetEnabledCiphers (
    SSLContextRef context,
    SSLCipherSuite *ciphers,
    size_t *numCiphers
);

OSStatus SSLGetEnabledCiphers (
    SSLContextRef _Nonnull context,
    SSLCipherSuite * _Nonnull ciphers,
    size_t * _Nonnull numCiphers
);

OSStatus SSLGetMaxDatagramRecordSize (
    SSLContextRef dtlsContext,
    size_t *maxSize
);

OSStatus SSLGetMaxDatagramRecordSize (
    SSLContextRef _Nonnull dtlsContext,
    size_t * _Nonnull maxSize
);

OSStatus SSLGetNegotiatedCipher (
    SSLContextRef context,
    SSLCipherSuite *cipherSuite
);

OSStatus SSLGetNegotiatedCipher (
    SSLContextRef _Nonnull context,
    SSLCipherSuite * _Nonnull cipherSuite
);

OSStatus SSLGetNegotiatedProtocolVersion (
    SSLContextRef context,
    SSLProtocol *protocol
);

OSStatus SSLGetNegotiatedProtocolVersion (
    SSLContextRef _Nonnull context,
    SSLProtocol * _Nonnull protocol
);

OSStatus SSLGetNumberEnabledCiphers (
    SSLContextRef context,
    size_t *numCiphers
);

OSStatus SSLGetNumberEnabledCiphers (
    SSLContextRef _Nonnull context,
    size_t * _Nonnull numCiphers
);

OSStatus SSLGetNumberSupportedCiphers (
    SSLContextRef context,
    size_t *numCiphers
);

OSStatus SSLGetNumberSupportedCiphers (
    SSLContextRef _Nonnull context,
    size_t * _Nonnull numCiphers
);

OSStatus SSLGetPeerDomainName (
    SSLContextRef context,
    char *peerName,
    size_t *peerNameLen
);

OSStatus SSLGetPeerDomainName (
    SSLContextRef _Nonnull context,
    char * _Nonnull peerName,
    size_t * _Nonnull peerNameLen
);

OSStatus SSLGetPeerDomainNameLength (
    SSLContextRef context,
    size_t *peerNameLen
);

OSStatus SSLGetPeerDomainNameLength (
    SSLContextRef _Nonnull context,
    size_t * _Nonnull peerNameLen
);

OSStatus SSLGetPeerID (
    SSLContextRef context,
    const void **peerID,
    size_t *peerIDLen
);

OSStatus SSLGetPeerID (
    SSLContextRef _Nonnull context,
    const void * _Nullable * _Nonnull peerID,
    size_t * _Nonnull peerIDLen
);

OSStatus SSLGetProtocolVersion (
    SSLContextRef context,
    SSLProtocol *protocol
);

OSStatus SSLGetProtocolVersion (
    SSLContextRef _Nonnull context,
    SSLProtocol * _Nonnull protocol
);

OSStatus SSLGetProtocolVersionEnabled (
    SSLContextRef context,
    SSLProtocol protocol,
    Boolean *enable
);

OSStatus SSLGetProtocolVersionEnabled (
    SSLContextRef _Nonnull context,
    SSLProtocol protocol,
    Boolean * _Nonnull enable
);

OSStatus SSLGetProtocolVersionMax (
    SSLContextRef context,
    SSLProtocol *maxVersion
);

OSStatus SSLGetProtocolVersionMax (
    SSLContextRef _Nonnull context,
    SSLProtocol * _Nonnull maxVersion
);

OSStatus SSLGetProtocolVersionMin (
    SSLContextRef context,
    SSLProtocol *minVersion
);

OSStatus SSLGetProtocolVersionMin (
    SSLContextRef _Nonnull context,
    SSLProtocol * _Nonnull minVersion
);

OSStatus SSLGetRsaBlinding (
    SSLContextRef context,
    Boolean *blinding
);

OSStatus SSLGetRsaBlinding (
    SSLContextRef _Nonnull context,
    Boolean * _Nonnull blinding
);

OSStatus SSLGetSessionOption (
    SSLContextRef context,
    SSLSessionOption option,
    Boolean *value
);

OSStatus SSLGetSessionOption (
    SSLContextRef _Nonnull context,
    SSLSessionOption option,
    Boolean * _Nonnull value
);

OSStatus SSLGetSessionState (
    SSLContextRef context,
    SSLSessionState *state
);

OSStatus SSLGetSessionState (
    SSLContextRef _Nonnull context,
    SSLSessionState * _Nonnull state
);

OSStatus SSLGetSupportedCiphers (
    SSLContextRef context,
    SSLCipherSuite *ciphers,
    size_t *numCiphers
);

OSStatus SSLGetSupportedCiphers (
    SSLContextRef _Nonnull context,
    SSLCipherSuite * _Nonnull ciphers,
    size_t * _Nonnull numCiphers
);

OSStatus SSLHandshake (
    SSLContextRef context
);

OSStatus SSLHandshake (
    SSLContextRef _Nonnull context
);

OSStatus SSLNewContext (
    Boolean isServer,
    SSLContextRef *contextPtr
);

OSStatus SSLNewContext (
    Boolean isServer,
    SSLContextRef  _Nullable * _Nonnull contextPtr
);

OSStatus SSLRead (
    SSLContextRef context,
    void *data,
    size_t dataLength,
    size_t *processed
);

OSStatus SSLRead (
    SSLContextRef _Nonnull context,
    void * _Nonnull data,
    size_t dataLength,
    size_t * _Nonnull processed
);

OSStatus SSLSetAllowsAnyRoot (
    SSLContextRef context,
    Boolean anyRoot
);

OSStatus SSLSetAllowsAnyRoot (
    SSLContextRef _Nonnull context,
    Boolean anyRoot
);

OSStatus SSLSetAllowsExpiredCerts (
    SSLContextRef context,
    Boolean allowsExpired
);

OSStatus SSLSetAllowsExpiredCerts (
    SSLContextRef _Nonnull context,
    Boolean allowsExpired
);

OSStatus SSLSetAllowsExpiredRoots (
    SSLContextRef context,
    Boolean allowsExpired
);

OSStatus SSLSetAllowsExpiredRoots (
    SSLContextRef _Nonnull context,
    Boolean allowsExpired
);

OSStatus SSLSetCertificate (
    SSLContextRef context,
    CFArrayRef certRefs
);

OSStatus SSLSetCertificate (
    SSLContextRef _Nonnull context,
    CFArrayRef _Nonnull certRefs
);

OSStatus SSLSetCertificateAuthorities (
    SSLContextRef context,
    CFTypeRef certificateOrArray,
    Boolean replaceExisting
);

OSStatus SSLSetCertificateAuthorities (
    SSLContextRef _Nonnull context,
    CFTypeRef _Nonnull certificateOrArray,
    Boolean replaceExisting
);

OSStatus SSLSetClientSideAuthenticate (
    SSLContextRef context,
    SSLAuthenticate auth
);

OSStatus SSLSetClientSideAuthenticate (
    SSLContextRef _Nonnull context,
    SSLAuthenticate auth
);

OSStatus SSLSetConnection (
    SSLContextRef context,
    SSLConnectionRef connection
);

OSStatus SSLSetConnection (
    SSLContextRef _Nonnull context,
    SSLConnectionRef _Nullable connection
);

OSStatus SSLSetDatagramHelloCookie (
    SSLContextRef dtlsContext,
    const void *cookie,
    size_t cookieLen
);

OSStatus SSLSetDatagramHelloCookie (
    SSLContextRef _Nonnull dtlsContext,
    const void * _Nullable cookie,
    size_t cookieLen
);

OSStatus SSLSetDiffieHellmanParams (
    SSLContextRef context,
    const void *dhParams,
    size_t dhParamsLen
);

OSStatus SSLSetDiffieHellmanParams (
    SSLContextRef _Nonnull context,
    const void * _Nullable dhParams,
    size_t dhParamsLen
);

OSStatus SSLSetEnableCertVerify (
    SSLContextRef context,
    Boolean enableVerify
);

OSStatus SSLSetEnableCertVerify (
    SSLContextRef _Nonnull context,
    Boolean enableVerify
);

OSStatus SSLSetEnabledCiphers (
    SSLContextRef context,
    const SSLCipherSuite *ciphers,
    size_t numCiphers
);

OSStatus SSLSetEnabledCiphers (
    SSLContextRef _Nonnull context,
    const SSLCipherSuite * _Nonnull ciphers,
    size_t numCiphers
);

OSStatus SSLSetEncryptionCertificate (
    SSLContextRef context,
    CFArrayRef certRefs
);

OSStatus SSLSetEncryptionCertificate (
    SSLContextRef _Nonnull context,
    CFArrayRef _Nonnull certRefs
);

OSStatus SSLSetIOFuncs (
    SSLContextRef context,
    SSLReadFunc readFunc,
    SSLWriteFunc writeFunc
);

OSStatus SSLSetIOFuncs (
    SSLContextRef _Nonnull context,
    SSLReadFunc _Nonnull readFunc,
    SSLWriteFunc _Nonnull writeFunc
);

OSStatus SSLSetMaxDatagramRecordSize (
    SSLContextRef dtlsContext,
    size_t maxSize
);

OSStatus SSLSetMaxDatagramRecordSize (
    SSLContextRef _Nonnull dtlsContext,
    size_t maxSize
);

OSStatus SSLSetPeerDomainName (
    SSLContextRef context,
    const char *peerName,
    size_t peerNameLen
);

OSStatus SSLSetPeerDomainName (
    SSLContextRef _Nonnull context,
    const char * _Nullable peerName,
    size_t peerNameLen
);

OSStatus SSLSetPeerID (
    SSLContextRef context,
    const void *peerID,
    size_t peerIDLen
);

OSStatus SSLSetPeerID (
    SSLContextRef _Nonnull context,
    const void * _Nullable peerID,
    size_t peerIDLen
);

OSStatus SSLSetProtocolVersion (
    SSLContextRef context,
    SSLProtocol version
);

OSStatus SSLSetProtocolVersion (
    SSLContextRef _Nonnull context,
    SSLProtocol version
);

OSStatus SSLSetProtocolVersionEnabled (
    SSLContextRef context,
    SSLProtocol protocol,
    Boolean enable
);

OSStatus SSLSetProtocolVersionEnabled (
    SSLContextRef _Nonnull context,
    SSLProtocol protocol,
    Boolean enable
);

OSStatus SSLSetProtocolVersionMax (
    SSLContextRef context,
    SSLProtocol maxVersion
);

OSStatus SSLSetProtocolVersionMax (
    SSLContextRef _Nonnull context,
    SSLProtocol maxVersion
);

OSStatus SSLSetProtocolVersionMin (
    SSLContextRef context,
    SSLProtocol minVersion
);

OSStatus SSLSetProtocolVersionMin (
    SSLContextRef _Nonnull context,
    SSLProtocol minVersion
);

OSStatus SSLSetRsaBlinding (
    SSLContextRef context,
    Boolean blinding
);

OSStatus SSLSetRsaBlinding (
    SSLContextRef _Nonnull context,
    Boolean blinding
);

OSStatus SSLSetSessionOption (
    SSLContextRef context,
    SSLSessionOption option,
    Boolean value
);

OSStatus SSLSetSessionOption (
    SSLContextRef _Nonnull context,
    SSLSessionOption option,
    Boolean value
);

OSStatus SSLSetTrustedRoots (
    SSLContextRef context,
    CFArrayRef trustedRoots,
    Boolean replaceExisting
);

OSStatus SSLSetTrustedRoots (
    SSLContextRef _Nonnull context,
    CFArrayRef _Nonnull trustedRoots,
    Boolean replaceExisting
);

OSStatus SSLWrite (
    SSLContextRef context,
    const void *data,
    size_t dataLength,
    size_t *processed
);

OSStatus SSLWrite (
    SSLContextRef _Nonnull context,
    const void * _Nullable data,
    size_t dataLength,
    size_t * _Nonnull processed
);