//! 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 crate::*;

extern_class!(
    /// An NSURLConnection object provides support to perform
    /// asynchronous loads of a URL request, providing data to a
    /// client supplied delegate.
    ///
    ///
    /// The interface for NSURLConnection is very sparse, providing
    /// only the controls to start and cancel asynchronous loads of a
    /// URL request.
    /// <p>
    ///
    /// An NSURLConnection may be used for loading of resource data
    /// directly to memory, in which case an
    /// NSURLConnectionDataDelegate should be supplied, or for
    /// downloading of resource data directly to a file, in which case
    /// an NSURLConnectionDownloadDelegate is used.  The delegate is
    /// retained by the NSURLConnection until a terminal condition is
    /// encountered.  These two delegates are logically subclasses of
    /// the base protocol, NSURLConnectionDelegate.
    /// <p>
    ///
    /// A terminal condition produced by the loader will result in a
    /// connection:didFailWithError: in the case of an error, or
    /// connectionDidFinishLoading: or connectionDidFinishDownloading:
    /// delegate message.
    /// <p>
    ///
    /// The -cancel message hints to the loader that a resource load
    /// should be abandoned but does not guarantee that more delegate
    /// messages will not be delivered.  If -cancel does cause the
    /// load to be abandoned, the delegate will be released without
    /// further messages.  In general, a caller should be prepared for
    /// -cancel to have no effect, and internally ignore any delegate
    /// callbacks until the delegate is released.
    ///
    /// Scheduling of an NSURLConnection specifies the context in
    /// which delegate callbacks will be made, but the actual IO may
    /// occur on a separate thread and should be considered an
    /// implementation detail.
    /// <p>
    ///
    /// When created, an NSURLConnection performs a deep-copy of the
    /// NSURLRequest.  This copy is available through the
    /// -originalRequest method.  As the connection performs the load,
    /// this request may change as a result of protocol
    /// canonicalization or due to following redirects.
    /// -currentRequest can be used to retrieve this value.
    /// <p>
    ///
    /// An NSURLConnections created with the
    /// +connectionWithRequest:delegate: or -initWithRequest:delegate:
    /// methods are scheduled on the current runloop immediately, and
    /// it is not necessary to send the -start message to begin the
    /// resource load.
    /// <p>
    ///
    /// NSURLConnections created with
    /// -initWithRequest:delegate:startImmediately: are not
    /// automatically scheduled.  Use -scheduleWithRunLoop:forMode: or
    /// -setDelegateQueue: to specify the context for delegate
    /// callbacks, and -start to begin the load.  If you do not
    /// explicitly schedule the connection before -start, it will be
    /// scheduled on the current runloop and mode automatically.
    /// <p>
    ///
    /// The NSURLConnectionSynchronousLoading category adds
    /// +sendSynchronousRequest:returningResponse:error, which blocks
    /// the current thread until the resource data is available or an
    /// error occurs.  It should be noted that using this method on an
    /// applications main run loop may result in an unacceptably long
    /// delay in a user interface and its use is strongly
    /// discourage.
    /// <p>
    ///
    /// The NSURLConnectionQueuedLoading category implements
    /// +sendAsynchronousRequest:queue:completionHandler, providing
    /// similar simplicity but provides a mechanism where the current
    /// runloop is not blocked.
    /// <p>
    ///
    /// Both of the immediate loading categories do not provide for
    /// customization of resource load, and do not allow the caller to
    /// respond to, e.g., authentication challenges.
    /// <p>
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nsurlconnection?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct NSURLConnection;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for NSURLConnection {}
);

impl NSURLConnection {
    extern_methods!(
        #[cfg(feature = "NSURLRequest")]
        /// # Safety
        ///
        /// `delegate` should be of the correct type.
        #[deprecated = "Use NSURLSession (see NSURLSession.h)"]
        #[unsafe(method(initWithRequest:delegate:startImmediately:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithRequest_delegate_startImmediately(
            this: Allocated<Self>,
            request: &NSURLRequest,
            delegate: Option<&AnyObject>,
            start_immediately: bool,
        ) -> Option<Retained<Self>>;

        #[cfg(feature = "NSURLRequest")]
        /// # Safety
        ///
        /// `delegate` should be of the correct type.
        #[deprecated = "Use NSURLSession (see NSURLSession.h)"]
        #[unsafe(method(initWithRequest:delegate:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithRequest_delegate(
            this: Allocated<Self>,
            request: &NSURLRequest,
            delegate: Option<&AnyObject>,
        ) -> Option<Retained<Self>>;

        #[cfg(feature = "NSURLRequest")]
        /// # Safety
        ///
        /// `delegate` should be of the correct type.
        #[deprecated = "Use NSURLSession (see NSURLSession.h)"]
        #[unsafe(method(connectionWithRequest:delegate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn connectionWithRequest_delegate(
            request: &NSURLRequest,
            delegate: Option<&AnyObject>,
        ) -> Option<Retained<NSURLConnection>>;

        #[cfg(feature = "NSURLRequest")]
        #[unsafe(method(originalRequest))]
        #[unsafe(method_family = none)]
        pub fn originalRequest(&self) -> Retained<NSURLRequest>;

        #[cfg(feature = "NSURLRequest")]
        #[unsafe(method(currentRequest))]
        #[unsafe(method_family = none)]
        pub fn currentRequest(&self) -> Retained<NSURLRequest>;

        #[unsafe(method(start))]
        #[unsafe(method_family = none)]
        pub fn start(&self);

        #[unsafe(method(cancel))]
        #[unsafe(method_family = none)]
        pub fn cancel(&self);

        #[cfg(all(feature = "NSObjCRuntime", feature = "NSRunLoop", feature = "NSString"))]
        /// # Safety
        ///
        /// `a_run_loop` possibly has additional threading requirements.
        #[unsafe(method(scheduleInRunLoop:forMode:))]
        #[unsafe(method_family = none)]
        pub unsafe fn scheduleInRunLoop_forMode(
            &self,
            a_run_loop: &NSRunLoop,
            mode: &NSRunLoopMode,
        );

        #[cfg(all(feature = "NSObjCRuntime", feature = "NSRunLoop", feature = "NSString"))]
        /// # Safety
        ///
        /// `a_run_loop` possibly has additional threading requirements.
        #[unsafe(method(unscheduleFromRunLoop:forMode:))]
        #[unsafe(method_family = none)]
        pub unsafe fn unscheduleFromRunLoop_forMode(
            &self,
            a_run_loop: &NSRunLoop,
            mode: &NSRunLoopMode,
        );

        #[cfg(feature = "NSOperation")]
        /// # Safety
        ///
        /// `queue` possibly has additional threading requirements.
        #[unsafe(method(setDelegateQueue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelegateQueue(&self, queue: Option<&NSOperationQueue>);

        #[cfg(feature = "NSURLRequest")]
        /// Performs a "preflight" operation that performs
        /// some speculative checks to see if a connection can
        /// be initialized, and the associated I/O that is
        /// started in the initializer methods can begin.
        ///
        ///
        /// The result of this method is valid only as long as
        /// no protocols are registered or unregistered, and
        /// as long as the request is not mutated (if the
        /// request is mutable). Hence, clients should be
        /// prepared to handle failures even if they have
        /// performed request preflighting by calling this
        /// method.
        ///
        ///
        /// Parameter `request`: The request to preflight.
        ///
        ///
        /// Returns: YES if it is likely that the given request can be used to
        /// initialize a connection and the associated I/O can be
        /// started, NO otherwise.
        #[unsafe(method(canHandleRequest:))]
        #[unsafe(method_family = none)]
        pub fn canHandleRequest(request: &NSURLRequest) -> bool;
    );
}

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

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub fn new() -> Retained<Self>;
    );
}

impl DefaultRetained for NSURLConnection {
    #[inline]
    fn default_retained() -> Retained<Self> {
        Self::new()
    }
}

extern_protocol!(
    /// Delegate methods that are common to all forms of
    /// NSURLConnection.  These are all optional.  This
    /// protocol should be considered a base class for the
    /// NSURLConnectionDataDelegate and
    /// NSURLConnectionDownloadDelegate protocols.
    ///
    ///
    /// connection:didFailWithError: will be called at
    /// most once, if an error occurs during a resource
    /// load.  No other callbacks will be made after.
    /// <p>
    ///
    /// connectionShouldUseCredentialStorage: will be
    /// called at most once, before a resource load begins
    /// (which means it may be called during construction
    /// of the connection.)  The delegate should return
    /// TRUE if the connection should consult the shared
    /// NSURLCredentialStorage in response to
    /// authentication challenges.  Regardless of the
    /// result, the authentication challenge methods may
    /// still be called.
    ///
    /// connection:willSendRequestForAuthenticationChallenge:
    /// is the preferred (Mac OS X 10.7 and iOS 5.0 or
    /// later) mechanism for responding to authentication
    /// challenges.  See
    /// <Foundation
    /// /NSURLAuthenticationChallenge.h> for
    /// more information on dealing with the various types
    /// of authentication challenges.
    ///
    /// connection:canAuthenticateAgainstProtectionSpace:
    /// connection:didReceiveAuthenticationChallenge:
    /// connection:didCancelAuthenticationChallenge: are
    /// deprecated and new code should adopt
    /// connection:willSendRequestForAuthenticationChallenge.
    /// The older delegates will still be called for
    /// compatibility, but incur more latency in dealing
    /// with the authentication challenge.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nsurlconnectiondelegate?language=objc)
    pub unsafe trait NSURLConnectionDelegate: NSObjectProtocol {
        #[cfg(feature = "NSError")]
        #[optional]
        #[unsafe(method(connection:didFailWithError:))]
        #[unsafe(method_family = none)]
        fn connection_didFailWithError(&self, connection: &NSURLConnection, error: &NSError);

        #[optional]
        #[unsafe(method(connectionShouldUseCredentialStorage:))]
        #[unsafe(method_family = none)]
        fn connectionShouldUseCredentialStorage(&self, connection: &NSURLConnection) -> bool;

        #[cfg(feature = "NSURLAuthenticationChallenge")]
        #[optional]
        #[unsafe(method(connection:willSendRequestForAuthenticationChallenge:))]
        #[unsafe(method_family = none)]
        fn connection_willSendRequestForAuthenticationChallenge(
            &self,
            connection: &NSURLConnection,
            challenge: &NSURLAuthenticationChallenge,
        );

        #[cfg(feature = "NSURLProtectionSpace")]
        #[deprecated = "Use -connection:willSendRequestForAuthenticationChallenge: instead."]
        #[optional]
        #[unsafe(method(connection:canAuthenticateAgainstProtectionSpace:))]
        #[unsafe(method_family = none)]
        fn connection_canAuthenticateAgainstProtectionSpace(
            &self,
            connection: &NSURLConnection,
            protection_space: &NSURLProtectionSpace,
        ) -> bool;

        #[cfg(feature = "NSURLAuthenticationChallenge")]
        #[deprecated = "Use -connection:willSendRequestForAuthenticationChallenge: instead."]
        #[optional]
        #[unsafe(method(connection:didReceiveAuthenticationChallenge:))]
        #[unsafe(method_family = none)]
        fn connection_didReceiveAuthenticationChallenge(
            &self,
            connection: &NSURLConnection,
            challenge: &NSURLAuthenticationChallenge,
        );

        #[cfg(feature = "NSURLAuthenticationChallenge")]
        #[deprecated = "Use -connection:willSendRequestForAuthenticationChallenge: instead."]
        #[optional]
        #[unsafe(method(connection:didCancelAuthenticationChallenge:))]
        #[unsafe(method_family = none)]
        fn connection_didCancelAuthenticationChallenge(
            &self,
            connection: &NSURLConnection,
            challenge: &NSURLAuthenticationChallenge,
        );
    }
);

extern_protocol!(
    /// Delegate methods used for loading data to memory.
    /// These delegate methods are all optional.
    ///
    ///
    /// connection:willSendRequest:redirectResponse: is
    /// called whenever an connection determines that it
    /// must change URLs in order to continue loading a
    /// request.  This gives the delegate an opportunity
    /// inspect and if necessary modify a request.  A
    /// delegate can cause the request to abort by either
    /// calling the connections -cancel method, or by
    /// returning nil from this callback.
    /// <p>
    ///
    /// There is one subtle difference which results from
    /// this choice. If -cancel is called in the delegate
    /// method, all processing for the connection stops,
    /// and no further delegate callbacks will be sent. If
    /// the delegate returns nil, the connection will
    /// continue to process, and this has special
    /// relevance in the case where the redirectResponse
    /// argument is non-nil. In this case, any data that
    /// is loaded for the connection will be sent to the
    /// delegate, and the delegate will receive a finished
    /// or failure delegate callback as appropriate.
    /// <p>
    ///
    /// connection:didReceiveResponse: is called when
    /// enough data has been read to construct an
    /// NSURLResponse object. In the event of a protocol
    /// which may return multiple responses (such as HTTP
    /// multipart/x-mixed-replace) the delegate should be
    /// prepared to inspect the new response and make
    /// itself ready for data callbacks as appropriate.
    /// <p>
    ///
    /// connection:didReceiveData: is called with a single
    /// immutable NSData object to the delegate,
    /// representing the next portion of the data loaded
    /// from the connection.  This is the only guaranteed
    /// for the delegate to receive the data from the
    /// resource load.
    /// <p>
    ///
    /// connection:needNewBodyStream: is called when the
    /// loader must retransmit a requests payload, due to
    /// connection errors or authentication challenges.
    /// Delegates should construct a new unopened and
    /// autoreleased NSInputStream.  If not implemented,
    /// the loader will be required to spool the bytes to
    /// be uploaded to disk, a potentially expensive
    /// operation.  Returning nil will cancel the
    /// connection.
    ///
    /// connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite:
    /// is called during an upload operation to provide
    /// progress feedback.  Note that the values may
    /// change in unexpected ways if the request needs to
    /// be retransmitted.
    /// <p>
    ///
    /// connection:willCacheResponse: gives the delegate
    /// an opportunity to inspect and modify the
    /// NSCachedURLResponse which will be cached by the
    /// loader if caching is enabled for the original
    /// NSURLRequest.  Returning nil from this delegate
    /// will prevent the resource from being cached.  Note
    /// that the -data method of the cached response may
    /// return an autoreleased in-memory copy of the true
    /// data, and should not be used as an alternative to
    /// receiving and accumulating the data through
    /// connection:didReceiveData:
    /// <p>
    ///
    /// connectionDidFinishLoading: is called when all
    /// connection processing has completed successfully,
    /// before the delegate is released by the
    /// connection.
    /// <p>
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nsurlconnectiondatadelegate?language=objc)
    pub unsafe trait NSURLConnectionDataDelegate: NSURLConnectionDelegate {
        #[cfg(all(feature = "NSURLRequest", feature = "NSURLResponse"))]
        #[optional]
        #[unsafe(method(connection:willSendRequest:redirectResponse:))]
        #[unsafe(method_family = none)]
        fn connection_willSendRequest_redirectResponse(
            &self,
            connection: &NSURLConnection,
            request: &NSURLRequest,
            response: Option<&NSURLResponse>,
        ) -> Option<Retained<NSURLRequest>>;

        #[cfg(feature = "NSURLResponse")]
        #[optional]
        #[unsafe(method(connection:didReceiveResponse:))]
        #[unsafe(method_family = none)]
        fn connection_didReceiveResponse(
            &self,
            connection: &NSURLConnection,
            response: &NSURLResponse,
        );

        #[cfg(feature = "NSData")]
        #[optional]
        #[unsafe(method(connection:didReceiveData:))]
        #[unsafe(method_family = none)]
        fn connection_didReceiveData(&self, connection: &NSURLConnection, data: &NSData);

        #[cfg(all(feature = "NSStream", feature = "NSURLRequest"))]
        #[optional]
        #[unsafe(method(connection:needNewBodyStream:))]
        #[unsafe(method_family = none)]
        fn connection_needNewBodyStream(
            &self,
            connection: &NSURLConnection,
            request: &NSURLRequest,
        ) -> Option<Retained<NSInputStream>>;

        #[optional]
        #[unsafe(method(connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite:))]
        #[unsafe(method_family = none)]
        fn connection_didSendBodyData_totalBytesWritten_totalBytesExpectedToWrite(
            &self,
            connection: &NSURLConnection,
            bytes_written: NSInteger,
            total_bytes_written: NSInteger,
            total_bytes_expected_to_write: NSInteger,
        );

        #[cfg(feature = "NSURLCache")]
        #[optional]
        #[unsafe(method(connection:willCacheResponse:))]
        #[unsafe(method_family = none)]
        fn connection_willCacheResponse(
            &self,
            connection: &NSURLConnection,
            cached_response: &NSCachedURLResponse,
        ) -> Option<Retained<NSCachedURLResponse>>;

        #[optional]
        #[unsafe(method(connectionDidFinishLoading:))]
        #[unsafe(method_family = none)]
        fn connectionDidFinishLoading(&self, connection: &NSURLConnection);
    }
);

extern_protocol!(
    /// Delegate methods used to perform resource
    /// downloads directly to a disk file.  All the
    /// methods are optional with the exception of
    /// connectionDidFinishDownloading:destinationURL:
    /// which must be implemented in order to inform the
    /// delegate of the location of the finished download.
    /// This delegate and download implementation is
    /// currently only available on iOS 5.0 or later.
    ///
    ///
    /// connection:didWriteData:totalBytesWritten:expectedTotalBytes:
    /// provides progress information about the state of
    /// the download, the number of bytes written since
    /// the last delegate callback, the total number of
    /// bytes written to disk and the total number of
    /// bytes that are expected (or 0 if this is unknown.)
    ///
    /// connectionDidResumeDownloading:totalBytesWritten:expectedTotalBytes:
    /// is called when the connection is able to resume an
    /// in progress download.  This may happen due to a
    /// connection or network failure.
    ///
    /// connectionDidFinishDownloading:destinationURL: is
    /// a terminal event which indicates the completion of
    /// a download and provides the location of the file.
    /// The file will be located in the applications cache
    /// directory and is guaranteed to exist for the
    /// duration of the delegate callback.  The
    /// implication is that the delegate should copy or
    /// move the download to a more persistent location if
    /// desired.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nsurlconnectiondownloaddelegate?language=objc)
    pub unsafe trait NSURLConnectionDownloadDelegate: NSURLConnectionDelegate {
        #[optional]
        #[unsafe(method(connection:didWriteData:totalBytesWritten:expectedTotalBytes:))]
        #[unsafe(method_family = none)]
        fn connection_didWriteData_totalBytesWritten_expectedTotalBytes(
            &self,
            connection: &NSURLConnection,
            bytes_written: c_longlong,
            total_bytes_written: c_longlong,
            expected_total_bytes: c_longlong,
        );

        #[optional]
        #[unsafe(method(connectionDidResumeDownloading:totalBytesWritten:expectedTotalBytes:))]
        #[unsafe(method_family = none)]
        fn connectionDidResumeDownloading_totalBytesWritten_expectedTotalBytes(
            &self,
            connection: &NSURLConnection,
            total_bytes_written: c_longlong,
            expected_total_bytes: c_longlong,
        );

        #[cfg(feature = "NSURL")]
        #[unsafe(method(connectionDidFinishDownloading:destinationURL:))]
        #[unsafe(method_family = none)]
        fn connectionDidFinishDownloading_destinationURL(
            &self,
            connection: &NSURLConnection,
            destination_url: &NSURL,
        );
    }
);

/// NSURLConnectionSynchronousLoading.
///
/// The NSURLConnectionSynchronousLoading category on
/// NSURLConnection provides the interface to perform
/// synchronous loading of URL requests.
impl NSURLConnection {
    extern_methods!(
        #[cfg(all(
            feature = "NSData",
            feature = "NSError",
            feature = "NSURLRequest",
            feature = "NSURLResponse"
        ))]
        /// Performs a synchronous load of the given request,
        /// returning an NSURLResponse in the given out
        /// parameter.
        ///
        ///
        /// A synchronous load for the given request is built on
        /// top of the asynchronous loading code made available
        /// by the class.  The calling thread is blocked while
        /// the asynchronous loading system performs the URL load
        /// on a thread spawned specifically for this load
        /// request. No special threading or run loop
        /// configuration is necessary in the calling thread in
        /// order to perform a synchronous load. For instance,
        /// the calling thread need not be running its run loop.
        ///
        ///
        /// Parameter `request`: The request to load. Note that the request is
        /// deep-copied as part of the initialization
        /// process. Changes made to the request argument after
        /// this method returns do not affect the request that is
        /// used for the loading process.
        ///
        ///
        /// Parameter `response`: An out parameter which is filled in with the
        /// response generated by performing the load.
        ///
        ///
        /// Parameter `error`: Out parameter (may be NULL) used if an error occurs
        /// while processing the request. Will not be modified if the
        /// load succeeds.
        ///
        ///
        /// Returns: The content of the URL resulting from performing the load,
        /// or nil if the load failed.
        #[deprecated = "Use [NSURLSession dataTaskWithRequest:completionHandler:] (see NSURLSession.h"]
        #[unsafe(method(sendSynchronousRequest:returningResponse:error:_))]
        #[unsafe(method_family = none)]
        pub fn sendSynchronousRequest_returningResponse_error(
            request: &NSURLRequest,
            response: Option<&mut Option<Retained<NSURLResponse>>>,
        ) -> Result<Retained<NSData>, Retained<NSError>>;
    );
}

/// NSURLConnectionQueuedLoading.
///
/// The NSURLConnectionQueuedLoading category on NSURLConnection
/// provides the interface to perform asynchronous loading of URL
/// requests where the results of the request are delivered to a
/// block via an NSOperationQueue.
///
/// Note that there is no guarantee of load ordering implied by this
/// method.
impl NSURLConnection {
    extern_methods!(
        #[cfg(all(
            feature = "NSData",
            feature = "NSError",
            feature = "NSOperation",
            feature = "NSURLRequest",
            feature = "NSURLResponse",
            feature = "block2"
        ))]
        /// Performs an asynchronous load of the given
        /// request. When the request has completed or failed,
        /// the block will be executed from the context of the
        /// specified NSOperationQueue.
        ///
        ///
        /// This is a convenience routine that allows for
        /// asynchronous loading of a url-based resource.  If
        /// the resource load is successful, the data parameter
        /// to the callback will contain the resource data and
        /// the error parameter will be nil.  If the resource
        /// load fails, the data parameter will be nil and the
        /// error will contain information about the failure.
        ///
        ///
        /// Parameter `request`: The request to load. Note that the request is
        /// deep-copied as part of the initialization
        /// process. Changes made to the request argument after
        /// this method returns do not affect the request that
        /// is used for the loading process.
        ///
        ///
        /// Parameter `queue`: An NSOperationQueue upon which    the handler block will
        /// be dispatched.
        ///
        ///
        /// Parameter `handler`: A block which receives the results of the resource load.
        ///
        /// # Safety
        ///
        /// `queue` possibly has additional threading requirements.
        #[deprecated = "Use [NSURLSession dataTaskWithRequest:completionHandler:] (see NSURLSession.h"]
        #[unsafe(method(sendAsynchronousRequest:queue:completionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn sendAsynchronousRequest_queue_completionHandler(
            request: &NSURLRequest,
            queue: &NSOperationQueue,
            handler: &block2::DynBlock<dyn Fn(*mut NSURLResponse, *mut NSData, *mut NSError)>,
        );
    );
}