//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;

use crate::*;

/// Represents the current connection state of a CBPeripheral.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corebluetooth/cbperipheralstate?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CBPeripheralState(pub NSInteger);
impl CBPeripheralState {
    #[doc(alias = "CBPeripheralStateDisconnected")]
    pub const Disconnected: Self = Self(0);
    #[doc(alias = "CBPeripheralStateConnecting")]
    pub const Connecting: Self = Self(1);
    #[doc(alias = "CBPeripheralStateConnected")]
    pub const Connected: Self = Self(2);
    #[doc(alias = "CBPeripheralStateDisconnecting")]
    pub const Disconnecting: Self = Self(3);
}

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

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

/// Specifies which type of write is to be performed on a CBCharacteristic.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corebluetooth/cbcharacteristicwritetype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CBCharacteristicWriteType(pub NSInteger);
impl CBCharacteristicWriteType {
    #[doc(alias = "CBCharacteristicWriteWithResponse")]
    pub const WithResponse: Self = Self(0);
    #[doc(alias = "CBCharacteristicWriteWithoutResponse")]
    pub const WithoutResponse: Self = Self(1);
}

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

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

extern_class!(
    /// Represents a peripheral.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/corebluetooth/cbperipheral?language=objc)
    #[unsafe(super(CBPeer, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "CBPeer")]
    pub struct CBPeripheral;
);

#[cfg(feature = "CBPeer")]
unsafe impl NSCopying for CBPeripheral {}

#[cfg(feature = "CBPeer")]
unsafe impl CopyingHelper for CBPeripheral {
    type Result = Self;
}

#[cfg(feature = "CBPeer")]
unsafe impl NSObjectProtocol for CBPeripheral {}

#[cfg(feature = "CBPeer")]
impl CBPeripheral {
    extern_methods!(
        /// The delegate object that will receive peripheral events.
        #[unsafe(method(delegate))]
        #[unsafe(method_family = none)]
        pub unsafe fn delegate(&self)
            -> Option<Retained<ProtocolObject<dyn CBPeripheralDelegate>>>;

        /// This is a [weak property][objc2::topics::weak_property].
        /// Setter for [`delegate`][Self::delegate].
        #[unsafe(method(setDelegate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelegate(
            &self,
            delegate: Option<&ProtocolObject<dyn CBPeripheralDelegate>>,
        );

        /// The name of the peripheral.
        #[unsafe(method(name))]
        #[unsafe(method_family = none)]
        pub unsafe fn name(&self) -> Option<Retained<NSString>>;

        /// The most recently read RSSI, in decibels.
        ///
        ///
        /// ```text
        ///  peripheral:didReadRSSI:error:} instead.
        ///  
        ///
        /// ```
        #[deprecated]
        #[unsafe(method(RSSI))]
        #[unsafe(method_family = none)]
        pub unsafe fn RSSI(&self) -> Option<Retained<NSNumber>>;

        /// The current connection state of the peripheral.
        #[unsafe(method(state))]
        #[unsafe(method_family = none)]
        pub unsafe fn state(&self) -> CBPeripheralState;

        #[cfg(all(feature = "CBAttribute", feature = "CBService"))]
        /// A list of
        /// <code>
        /// CBService
        /// </code>
        /// objects that have been discovered on the peripheral.
        #[unsafe(method(services))]
        #[unsafe(method_family = none)]
        pub unsafe fn services(&self) -> Option<Retained<NSArray<CBService>>>;

        /// YES if the remote device has space to send a write without response. If this value is NO,
        /// the value will be set to YES after the current writes have been flushed, and
        /// <link
        /// >peripheralIsReadyToSendWriteWithoutResponse:
        /// </link
        /// > will be called.
        #[unsafe(method(canSendWriteWithoutResponse))]
        #[unsafe(method_family = none)]
        pub unsafe fn canSendWriteWithoutResponse(&self) -> bool;

        /// YES if the remote device has been authorized to receive data over ANCS (Apple Notification Service Center) protocol.  If this value is NO,
        /// the value will be set to YES after a user authorization occurs and
        /// <link
        /// >didUpdateANCSAuthorizationForPeripheral:
        /// </link
        /// > will be called.
        #[unsafe(method(ancsAuthorized))]
        #[unsafe(method_family = none)]
        pub unsafe fn ancsAuthorized(&self) -> bool;

        /// While connected, retrieves the current RSSI of the link.
        ///
        ///
        /// See: peripheral:didReadRSSI:error:
        #[unsafe(method(readRSSI))]
        #[unsafe(method_family = none)]
        pub unsafe fn readRSSI(&self);

        #[cfg(feature = "CBUUID")]
        /// Parameter `serviceUUIDs`: A list of
        /// <code>
        /// CBUUID
        /// </code>
        /// objects representing the service types to be discovered. If
        /// <i>
        /// nil
        /// </i>
        /// ,
        /// all services will be discovered.
        ///
        ///
        /// Discovers available service(s) on the peripheral.
        ///
        ///
        /// See: peripheral:didDiscoverServices:
        #[unsafe(method(discoverServices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn discoverServices(&self, service_uui_ds: Option<&NSArray<CBUUID>>);

        #[cfg(all(feature = "CBAttribute", feature = "CBService", feature = "CBUUID"))]
        /// Parameter `includedServiceUUIDs`: A list of
        /// <code>
        /// CBUUID
        /// </code>
        /// objects representing the included service types to be discovered. If
        /// <i>
        /// nil
        /// </i>
        /// ,
        /// all of
        /// <i>
        /// service
        /// </i>
        /// s included services will be discovered, which is considerably slower and not recommended.
        ///
        /// Parameter `service`: A GATT service.
        ///
        ///
        /// Discovers the specified included service(s) of
        /// <i>
        /// service
        /// </i>
        /// .
        ///
        ///
        /// See: peripheral:didDiscoverIncludedServicesForService:error:
        #[unsafe(method(discoverIncludedServices:forService:))]
        #[unsafe(method_family = none)]
        pub unsafe fn discoverIncludedServices_forService(
            &self,
            included_service_uui_ds: Option<&NSArray<CBUUID>>,
            service: &CBService,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBService", feature = "CBUUID"))]
        /// Parameter `characteristicUUIDs`: A list of
        /// <code>
        /// CBUUID
        /// </code>
        /// objects representing the characteristic types to be discovered. If
        /// <i>
        /// nil
        /// </i>
        /// ,
        /// all characteristics of
        /// <i>
        /// service
        /// </i>
        /// will be discovered.
        ///
        /// Parameter `service`: A GATT service.
        ///
        ///
        /// Discovers the specified characteristic(s) of
        /// <i>
        /// service
        /// </i>
        /// .
        ///
        ///
        /// See: peripheral:didDiscoverCharacteristicsForService:error:
        #[unsafe(method(discoverCharacteristics:forService:))]
        #[unsafe(method_family = none)]
        pub unsafe fn discoverCharacteristics_forService(
            &self,
            characteristic_uui_ds: Option<&NSArray<CBUUID>>,
            service: &CBService,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBCharacteristic"))]
        /// Parameter `characteristic`: A GATT characteristic.
        ///
        ///
        /// Reads the characteristic value for
        /// <i>
        /// characteristic
        /// </i>
        /// .
        ///
        ///
        /// See: peripheral:didUpdateValueForCharacteristic:error:
        #[unsafe(method(readValueForCharacteristic:))]
        #[unsafe(method_family = none)]
        pub unsafe fn readValueForCharacteristic(&self, characteristic: &CBCharacteristic);

        /// The maximum amount of data, in bytes, that can be sent to a characteristic in a single write type.
        ///
        ///
        /// See: writeValue:forCharacteristic:type:
        #[unsafe(method(maximumWriteValueLengthForType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumWriteValueLengthForType(
            &self,
            r#type: CBCharacteristicWriteType,
        ) -> NSUInteger;

        #[cfg(all(feature = "CBAttribute", feature = "CBCharacteristic"))]
        /// Parameter `data`: The value to write.
        ///
        /// Parameter `characteristic`: The characteristic whose characteristic value will be written.
        ///
        /// Parameter `type`: The type of write to be executed.
        ///
        ///
        /// Writes
        /// <i>
        /// value
        /// </i>
        /// to
        /// <i>
        /// characteristic
        /// </i>
        /// 's characteristic value.
        /// If the
        /// <code>
        /// CBCharacteristicWriteWithResponse
        /// </code>
        /// type is specified, {
        ///
        /// ```text
        ///  peripheral:didWriteValueForCharacteristic:error:}
        ///                             is called with the result of the write request.
        ///                             If the <code>CBCharacteristicWriteWithoutResponse</code> type is specified, and canSendWriteWithoutResponse is false, the delivery
        ///                              of the data is best-effort and may not be guaranteed.
        ///
        ///   @see                    peripheral:didWriteValueForCharacteristic:error:
        ///   @see                    peripheralIsReadyToSendWriteWithoutResponse:
        ///     @see                    canSendWriteWithoutResponse
        ///     @see                    CBCharacteristicWriteType
        ///  
        ///
        /// ```
        #[unsafe(method(writeValue:forCharacteristic:type:))]
        #[unsafe(method_family = none)]
        pub unsafe fn writeValue_forCharacteristic_type(
            &self,
            data: &NSData,
            characteristic: &CBCharacteristic,
            r#type: CBCharacteristicWriteType,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBCharacteristic"))]
        /// Parameter `enabled`: Whether or not notifications/indications should be enabled.
        ///
        /// Parameter `characteristic`: The characteristic containing the client characteristic configuration descriptor.
        ///
        ///
        /// Enables or disables notifications/indications for the characteristic value of
        /// <i>
        /// characteristic
        /// </i>
        /// . If
        /// <i>
        /// characteristic
        /// </i>
        /// allows both, notifications will be used.
        /// When notifications/indications are enabled, updates to the characteristic value will be received via delegate method
        ///
        /// ```text
        ///  peripheral:didUpdateValueForCharacteristic:error:
        /// ```
        ///
        /// . Since it is the peripheral that chooses when to send an update,
        /// the application should be prepared to handle them as long as notifications/indications remain enabled.
        ///
        ///
        /// See: peripheral:didUpdateNotificationStateForCharacteristic:error:
        ///
        /// See also: CBConnectPeripheralOptionNotifyOnNotificationKey
        #[unsafe(method(setNotifyValue:forCharacteristic:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setNotifyValue_forCharacteristic(
            &self,
            enabled: bool,
            characteristic: &CBCharacteristic,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBCharacteristic"))]
        /// Parameter `characteristic`: A GATT characteristic.
        ///
        ///
        /// Discovers the characteristic descriptor(s) of
        /// <i>
        /// characteristic
        /// </i>
        /// .
        ///
        ///
        /// See: peripheral:didDiscoverDescriptorsForCharacteristic:error:
        #[unsafe(method(discoverDescriptorsForCharacteristic:))]
        #[unsafe(method_family = none)]
        pub unsafe fn discoverDescriptorsForCharacteristic(
            &self,
            characteristic: &CBCharacteristic,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBDescriptor"))]
        /// Parameter `descriptor`: A GATT characteristic descriptor.
        ///
        ///
        /// Reads the value of
        /// <i>
        /// descriptor
        /// </i>
        /// .
        ///
        ///
        /// See: peripheral:didUpdateValueForDescriptor:error:
        #[unsafe(method(readValueForDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn readValueForDescriptor(&self, descriptor: &CBDescriptor);

        #[cfg(all(feature = "CBAttribute", feature = "CBDescriptor"))]
        /// Parameter `data`: The value to write.
        ///
        /// Parameter `descriptor`: A GATT characteristic descriptor.
        ///
        ///
        /// Writes
        /// <i>
        /// data
        /// </i>
        /// to
        /// <i>
        /// descriptor
        /// </i>
        /// 's value. Client characteristic configuration descriptors cannot be written using
        /// this method, and should instead use
        ///
        /// ```text
        ///  setNotifyValue:forCharacteristic:
        /// ```
        ///
        /// .
        ///
        ///
        /// See: peripheral:didWriteValueForCharacteristic:error:
        #[unsafe(method(writeValue:forDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn writeValue_forDescriptor(&self, data: &NSData, descriptor: &CBDescriptor);

        #[cfg(feature = "CBL2CAPChannel")]
        /// Parameter `PSM`: The PSM of the channel to open
        ///
        ///
        /// Attempt to open an L2CAP channel to the peripheral using the supplied PSM.
        ///
        ///
        /// See: peripheral:didWriteValueForCharacteristic:error:
        #[unsafe(method(openL2CAPChannel:))]
        #[unsafe(method_family = none)]
        pub unsafe fn openL2CAPChannel(&self, psm: CBL2CAPPSM);
    );
}

/// Methods declared on superclass `CBPeer`.
#[cfg(feature = "CBPeer")]
impl CBPeripheral {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "CBPeer")]
impl CBPeripheral {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// Delegate for CBPeripheral.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/corebluetooth/cbperipheraldelegate?language=objc)
    pub unsafe trait CBPeripheralDelegate: NSObjectProtocol {
        #[cfg(feature = "CBPeer")]
        /// Parameter `peripheral`: The peripheral providing this update.
        ///
        ///
        /// This method is invoked when the
        ///
        /// ```text
        ///  name
        /// ```
        ///
        /// of
        /// <i>
        /// peripheral
        /// </i>
        /// changes.
        #[optional]
        #[unsafe(method(peripheralDidUpdateName:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheralDidUpdateName(&self, peripheral: &CBPeripheral);

        #[cfg(all(feature = "CBAttribute", feature = "CBPeer", feature = "CBService"))]
        /// Parameter `peripheral`: The peripheral providing this update.
        ///
        /// Parameter `invalidatedServices`: The services that have been invalidated
        ///
        ///
        /// This method is invoked when the
        ///
        /// ```text
        ///  services
        /// ```
        ///
        /// of
        /// <i>
        /// peripheral
        /// </i>
        /// have been changed.
        /// At this point, the designated
        /// <code>
        /// CBService
        /// </code>
        /// objects have been invalidated.
        /// Services can be re-discovered via
        ///
        /// ```text
        ///  discoverServices:
        /// ```
        ///
        /// .
        #[optional]
        #[unsafe(method(peripheral:didModifyServices:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didModifyServices(
            &self,
            peripheral: &CBPeripheral,
            invalidated_services: &NSArray<CBService>,
        );

        #[cfg(feature = "CBPeer")]
        /// Parameter `peripheral`: The peripheral providing this update.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  readRSSI:
        /// ```
        ///
        /// call.
        ///
        ///
        /// ```text
        ///  peripheral:didReadRSSI:error:} instead.
        ///  
        ///
        /// ```
        #[deprecated]
        #[optional]
        #[unsafe(method(peripheralDidUpdateRSSI:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheralDidUpdateRSSI_error(
            &self,
            peripheral: &CBPeripheral,
            error: Option<&NSError>,
        );

        #[cfg(feature = "CBPeer")]
        /// Parameter `peripheral`: The peripheral providing this update.
        ///
        /// Parameter `RSSI`: The current RSSI of the link.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  readRSSI:
        /// ```
        ///
        /// call.
        #[optional]
        #[unsafe(method(peripheral:didReadRSSI:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didReadRSSI_error(
            &self,
            peripheral: &CBPeripheral,
            rssi: &NSNumber,
            error: Option<&NSError>,
        );

        #[cfg(feature = "CBPeer")]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  discoverServices:
        /// ```
        ///
        /// call. If the service(s) were read successfully, they can be retrieved via
        /// <i>
        /// peripheral
        /// </i>
        /// 's
        ///
        /// ```text
        ///  services
        /// ```
        ///
        /// property.
        #[optional]
        #[unsafe(method(peripheral:didDiscoverServices:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didDiscoverServices(
            &self,
            peripheral: &CBPeripheral,
            error: Option<&NSError>,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBPeer", feature = "CBService"))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `service`: The
        /// <code>
        /// CBService
        /// </code>
        /// object containing the included services.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  discoverIncludedServices:forService:
        /// ```
        ///
        /// call. If the included service(s) were read successfully,
        /// they can be retrieved via
        /// <i>
        /// service
        /// </i>
        /// 's
        /// <code>
        /// includedServices
        /// </code>
        /// property.
        #[optional]
        #[unsafe(method(peripheral:didDiscoverIncludedServicesForService:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didDiscoverIncludedServicesForService_error(
            &self,
            peripheral: &CBPeripheral,
            service: &CBService,
            error: Option<&NSError>,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBPeer", feature = "CBService"))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `service`: The
        /// <code>
        /// CBService
        /// </code>
        /// object containing the characteristic(s).
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  discoverCharacteristics:forService:
        /// ```
        ///
        /// call. If the characteristic(s) were read successfully,
        /// they can be retrieved via
        /// <i>
        /// service
        /// </i>
        /// 's
        /// <code>
        /// characteristics
        /// </code>
        /// property.
        #[optional]
        #[unsafe(method(peripheral:didDiscoverCharacteristicsForService:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didDiscoverCharacteristicsForService_error(
            &self,
            peripheral: &CBPeripheral,
            service: &CBService,
            error: Option<&NSError>,
        );

        #[cfg(all(
            feature = "CBAttribute",
            feature = "CBCharacteristic",
            feature = "CBPeer"
        ))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `characteristic`: A
        /// <code>
        /// CBCharacteristic
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method is invoked after a
        ///
        /// ```text
        ///  readValueForCharacteristic:
        /// ```
        ///
        /// call, or upon receipt of a notification/indication.
        #[optional]
        #[unsafe(method(peripheral:didUpdateValueForCharacteristic:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didUpdateValueForCharacteristic_error(
            &self,
            peripheral: &CBPeripheral,
            characteristic: &CBCharacteristic,
            error: Option<&NSError>,
        );

        #[cfg(all(
            feature = "CBAttribute",
            feature = "CBCharacteristic",
            feature = "CBPeer"
        ))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `characteristic`: A
        /// <code>
        /// CBCharacteristic
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a {
        ///
        /// ```text
        ///  writeValue:forCharacteristic:type:} call, when the <code>CBCharacteristicWriteWithResponse</code> type is used.
        ///  
        ///
        /// ```
        #[optional]
        #[unsafe(method(peripheral:didWriteValueForCharacteristic:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didWriteValueForCharacteristic_error(
            &self,
            peripheral: &CBPeripheral,
            characteristic: &CBCharacteristic,
            error: Option<&NSError>,
        );

        #[cfg(all(
            feature = "CBAttribute",
            feature = "CBCharacteristic",
            feature = "CBPeer"
        ))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `characteristic`: A
        /// <code>
        /// CBCharacteristic
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  setNotifyValue:forCharacteristic:
        /// ```
        ///
        /// call.
        #[optional]
        #[unsafe(method(peripheral:didUpdateNotificationStateForCharacteristic:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didUpdateNotificationStateForCharacteristic_error(
            &self,
            peripheral: &CBPeripheral,
            characteristic: &CBCharacteristic,
            error: Option<&NSError>,
        );

        #[cfg(all(
            feature = "CBAttribute",
            feature = "CBCharacteristic",
            feature = "CBPeer"
        ))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `characteristic`: A
        /// <code>
        /// CBCharacteristic
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  discoverDescriptorsForCharacteristic:
        /// ```
        ///
        /// call. If the descriptors were read successfully,
        /// they can be retrieved via
        /// <i>
        /// characteristic
        /// </i>
        /// 's
        /// <code>
        /// descriptors
        /// </code>
        /// property.
        #[optional]
        #[unsafe(method(peripheral:didDiscoverDescriptorsForCharacteristic:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didDiscoverDescriptorsForCharacteristic_error(
            &self,
            peripheral: &CBPeripheral,
            characteristic: &CBCharacteristic,
            error: Option<&NSError>,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBDescriptor", feature = "CBPeer"))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `descriptor`: A
        /// <code>
        /// CBDescriptor
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  readValueForDescriptor:
        /// ```
        ///
        /// call.
        #[optional]
        #[unsafe(method(peripheral:didUpdateValueForDescriptor:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didUpdateValueForDescriptor_error(
            &self,
            peripheral: &CBPeripheral,
            descriptor: &CBDescriptor,
            error: Option<&NSError>,
        );

        #[cfg(all(feature = "CBAttribute", feature = "CBDescriptor", feature = "CBPeer"))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `descriptor`: A
        /// <code>
        /// CBDescriptor
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  writeValue:forDescriptor:
        /// ```
        ///
        /// call.
        #[optional]
        #[unsafe(method(peripheral:didWriteValueForDescriptor:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didWriteValueForDescriptor_error(
            &self,
            peripheral: &CBPeripheral,
            descriptor: &CBDescriptor,
            error: Option<&NSError>,
        );

        #[cfg(feature = "CBPeer")]
        /// Parameter `peripheral`: The peripheral providing this update.
        ///
        ///
        /// This method is invoked after a failed call to
        ///
        /// ```text
        ///  writeValue:forCharacteristic:type:
        /// ```
        ///
        /// , when
        /// <i>
        /// peripheral
        /// </i>
        /// is again
        /// ready to send characteristic value updates.
        #[optional]
        #[unsafe(method(peripheralIsReadyToSendWriteWithoutResponse:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheralIsReadyToSendWriteWithoutResponse(&self, peripheral: &CBPeripheral);

        #[cfg(all(feature = "CBL2CAPChannel", feature = "CBPeer"))]
        /// Parameter `peripheral`: The peripheral providing this information.
        ///
        /// Parameter `channel`: A
        /// <code>
        /// CBL2CAPChannel
        /// </code>
        /// object.
        ///
        /// Parameter `error`: If an error occurred, the cause of the failure.
        ///
        ///
        /// This method returns the result of a
        ///
        /// ```text
        ///  openL2CAPChannel: @link call.
        ///  
        ///
        /// ```
        #[optional]
        #[unsafe(method(peripheral:didOpenL2CAPChannel:error:))]
        #[unsafe(method_family = none)]
        unsafe fn peripheral_didOpenL2CAPChannel_error(
            &self,
            peripheral: &CBPeripheral,
            channel: Option<&CBL2CAPChannel>,
            error: Option<&NSError>,
        );
    }
);
