New commit

Podfile

@@ -0,0 +1,26 @@
+# Uncomment the next line to define a global platform for your project
+# platform :ios, '9.0'
+
+target 'Product Calculator' do
+  # Comment the next line if you don't want to use dynamic frameworks
+  use_frameworks!
+
+  # Pods for Product Calculator
+  pod 'SwiftyGif'
+  pod 'GoogleSignIn'
+  pod 'SideMenu'
+  pod 'Alamofire'
+  pod 'Toast-Swift'
+  pod 'SwiftyJSON'
+  pod 'IQKeyboardManagerSwift'
+
+  target 'Product CalculatorTests' do
+    inherit! :search_paths
+    # Pods for testing
+  end
+
+  target 'Product CalculatorUITests' do
+    # Pods for testing
+  end
+
+end

Podfile.lock

@@ -0,0 +1,62 @@
+PODS:
+  - Alamofire (5.4.4)
+  - AppAuth (1.4.0):
+    - AppAuth/Core (= 1.4.0)
+    - AppAuth/ExternalUserAgent (= 1.4.0)
+  - AppAuth/Core (1.4.0)
+  - AppAuth/ExternalUserAgent (1.4.0)
+  - GoogleSignIn (6.0.2):
+    - AppAuth (~> 1.4)
+    - GTMAppAuth (~> 1.0)
+    - GTMSessionFetcher/Core (~> 1.1)
+  - GTMAppAuth (1.2.2):
+    - AppAuth/Core (~> 1.4)
+    - GTMSessionFetcher/Core (~> 1.5)
+  - GTMSessionFetcher/Core (1.7.0)
+  - IQKeyboardManagerSwift (6.5.6)
+  - SideMenu (6.5.0)
+  - SwiftDataTables (0.8.2)
+  - SwiftyGif (5.4.0)
+  - SwiftyJSON (5.0.1)
+  - Toast-Swift (5.0.1)
+
+DEPENDENCIES:
+  - Alamofire
+  - GoogleSignIn
+  - IQKeyboardManagerSwift
+  - SideMenu
+  - SwiftDataTables
+  - SwiftyGif
+  - SwiftyJSON
+  - Toast-Swift
+
+SPEC REPOS:
+  trunk:
+    - Alamofire
+    - AppAuth
+    - GoogleSignIn
+    - GTMAppAuth
+    - GTMSessionFetcher
+    - IQKeyboardManagerSwift
+    - SideMenu
+    - SwiftDataTables
+    - SwiftyGif
+    - SwiftyJSON
+    - Toast-Swift
+
+SPEC CHECKSUMS:
+  Alamofire: f3b09a368f1582ab751b3fff5460276e0d2cf5c9
+  AppAuth: 31bcec809a638d7bd2f86ea8a52bd45f6e81e7c7
+  GoogleSignIn: fd381840dbe7c1137aa6dc30849a5c3e070c034a
+  GTMAppAuth: ad5c2b70b9a8689e1a04033c9369c4915bfcbe89
+  GTMSessionFetcher: 43748f93435c2aa068b1cbe39655aaf600652e91
+  IQKeyboardManagerSwift: c7df9d2deb356c04522f5c4b7b6e4ce4d8ed94fe
+  SideMenu: f583187d21c5b1dd04c72002be544b555a2627a2
+  SwiftDataTables: 1c6bd4d477b44b07df86ca22c5ae67c85fe894ff
+  SwiftyGif: 5d4af95df24caf1c570dbbcb32a3b8a0763bc6d7
+  SwiftyJSON: 2f33a42c6fbc52764d96f13368585094bfd8aa5e
+  Toast-Swift: 9b6a70f28b3bf0b96c40d46c0c4b9d6639846711
+
+PODFILE CHECKSUM: 099bb5b3c73f906a143c0bf88ae370492c65cfd0
+
+COCOAPODS: 1.11.2

Pods/Alamofire/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014-2021 Alamofire Software Foundation (http://alamofire.org/)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Pods/Alamofire/README.md

@@ -0,0 +1,221 @@
+![Alamofire: Elegant Networking in Swift](https://raw.githubusercontent.com/Alamofire/Alamofire/master/Resources/AlamofireLogo.png)
+
+[![Swift](https://img.shields.io/badge/Swift-5.1_5.2_5.3_5.4-orange?style=flat-square)](https://img.shields.io/badge/Swift-5.1_5.2_5.3_5.4-Orange?style=flat-square)
+[![Platforms](https://img.shields.io/badge/Platforms-macOS_iOS_tvOS_watchOS_Linux_Windows-yellowgreen?style=flat-square)](https://img.shields.io/badge/Platforms-macOS_iOS_tvOS_watchOS_Linux_Windows-Green?style=flat-square)
+[![CocoaPods Compatible](https://img.shields.io/cocoapods/v/Alamofire.svg?style=flat-square)](https://img.shields.io/cocoapods/v/Alamofire.svg)
+[![Carthage Compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat-square)](https://github.com/Carthage/Carthage)
+[![Swift Package Manager](https://img.shields.io/badge/Swift_Package_Manager-compatible-orange?style=flat-square)](https://img.shields.io/badge/Swift_Package_Manager-compatible-orange?style=flat-square)
+[![Twitter](https://img.shields.io/badge/twitter-@AlamofireSF-blue.svg?style=flat-square)](https://twitter.com/AlamofireSF)
+[![Swift Forums](https://img.shields.io/badge/Swift_Forums-Alamofire-orange?style=flat-square)](https://forums.swift.org/c/related-projects/alamofire/37)
+
+Alamofire is an HTTP networking library written in Swift.
+
+- [Features](#features)
+- [Component Libraries](#component-libraries)
+- [Requirements](#requirements)
+- [Migration Guides](#migration-guides)
+- [Communication](#communication)
+- [Installation](#installation)
+- [Usage](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#using-alamofire)
+    - [**Introduction -**](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#introduction) [Making Requests](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#making-requests), [Response Handling](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#response-handling), [Response Validation](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#response-validation), [Response Caching](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#response-caching)
+	- **HTTP -** [HTTP Methods](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#http-methods), [Parameters and Parameter Encoder](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md##request-parameters-and-parameter-encoders), [HTTP Headers](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#http-headers), [Authentication](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#authentication)
+	- **Large Data -** [Downloading Data to a File](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#downloading-data-to-a-file), [Uploading Data to a Server](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#uploading-data-to-a-server)
+	- **Tools -** [Statistical Metrics](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#statistical-metrics), [cURL Command Output](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#curl-command-output)
+- [Advanced Usage](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md)
+	- **URL Session -** [Session Manager](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#session), [Session Delegate](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#sessiondelegate), [Request](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#request)
+	- **Routing -** [Routing Requests](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#routing-requests), [Adapting and Retrying Requests](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#adapting-and-retrying-requests-with-requestinterceptor)
+	- **Model Objects -** [Custom Response Handlers](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#customizing-response-handlers)
+	- **Connection -** [Security](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#security), [Network Reachability](https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md#network-reachability)
+- [Open Radars](#open-radars)
+- [FAQ](#faq)
+- [Credits](#credits)
+- [Donations](#donations)
+- [License](#license)
+
+## Features
+
+- [x] Chainable Request / Response Methods
+- [x] Combine Support
+- [x] URL / JSON Parameter Encoding
+- [x] Upload File / Data / Stream / MultipartFormData
+- [x] Download File using Request or Resume Data
+- [x] Authentication with `URLCredential`
+- [x] HTTP Response Validation
+- [x] Upload and Download Progress Closures with Progress
+- [x] cURL Command Output
+- [x] Dynamically Adapt and Retry Requests
+- [x] TLS Certificate and Public Key Pinning
+- [x] Network Reachability
+- [x] Comprehensive Unit and Integration Test Coverage
+- [x] [Complete Documentation](https://alamofire.github.io/Alamofire)
+
+## Component Libraries
+
+In order to keep Alamofire focused specifically on core networking implementations, additional component libraries have been created by the [Alamofire Software Foundation](https://github.com/Alamofire/Foundation) to bring additional functionality to the Alamofire ecosystem.
+
+- [AlamofireImage](https://github.com/Alamofire/AlamofireImage) - An image library including image response serializers, `UIImage` and `UIImageView` extensions, custom image filters, an auto-purging in-memory cache, and a priority-based image downloading system.
+- [AlamofireNetworkActivityIndicator](https://github.com/Alamofire/AlamofireNetworkActivityIndicator) - Controls the visibility of the network activity indicator on iOS using Alamofire. It contains configurable delay timers to help mitigate flicker and can support `URLSession` instances not managed by Alamofire.
+
+## Requirements
+
+| Platform | Minimum Swift Version | Installation | Status |
+| --- | --- | --- | --- |
+| iOS 10.0+ / macOS 10.12+ / tvOS 10.0+ / watchOS 3.0+ | 5.1 | [CocoaPods](#cocoapods), [Carthage](#carthage), [Swift Package Manager](#swift-package-manager), [Manual](#manually) | Fully Tested |
+| Linux | Latest Only | [Swift Package Manager](#swift-package-manager) | Building But Unsupported |
+| Windows | Latest Only | [Swift Package Manager](#swift-package-manager) | Building But Unsupported |
+
+#### Known Issues on Linux and Windows
+
+Alamofire builds on Linux and Windows but there are missing features and many issues in the underlying `swift-corelibs-foundation` that prevent full functionality and may cause crashes. These include:
+- `ServerTrustManager` and associated certificate functionality is unavailable, so there is no certificate pinning and no client certificate support.
+- Various methods of HTTP authentication may crash, including HTTP Basic and HTTP Digest. Crashes may occur if responses contain server challenges.
+- Cache control through `CachedResponseHandler` and associated APIs is unavailable, as the underlying delegate methods aren't called.
+- `URLSessionTaskMetrics` are never gathered.
+
+Due to these issues, Alamofire is unsupported on Linux and Windows. Please report any crashes to the [Swift bug reporter](https://bugs.swift.org).
+
+## Migration Guides
+
+- [Alamofire 5.0 Migration Guide](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Alamofire%205.0%20Migration%20Guide.md)
+- [Alamofire 4.0 Migration Guide](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Alamofire%204.0%20Migration%20Guide.md)
+- [Alamofire 3.0 Migration Guide](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Alamofire%203.0%20Migration%20Guide.md)
+- [Alamofire 2.0 Migration Guide](https://github.com/Alamofire/Alamofire/blob/master/Documentation/Alamofire%202.0%20Migration%20Guide.md)
+
+## Communication
+- If you **need help with making network requests** using Alamofire, use [Stack Overflow](https://stackoverflow.com/questions/tagged/alamofire) and tag `alamofire`.
+- If you need to **find or understand an API**, check [our documentation](http://alamofire.github.io/Alamofire/) or [Apple's documentation for `URLSession`](https://developer.apple.com/documentation/foundation/url_loading_system), on top of which Alamofire is built.
+- If you need **help with an Alamofire feature**, use [our forum on swift.org](https://forums.swift.org/c/related-projects/alamofire).
+- If you'd like to **discuss Alamofire best practices**, use [our forum on swift.org](https://forums.swift.org/c/related-projects/alamofire).
+- If you'd like to **discuss a feature request**, use [our forum on swift.org](https://forums.swift.org/c/related-projects/alamofire). 
+- If you **found a bug**, open an issue here on GitHub and follow the guide. The more detail the better!
+- If you **want to contribute**, submit a pull request!
+
+## Installation
+
+### CocoaPods
+
+[CocoaPods](https://cocoapods.org) is a dependency manager for Cocoa projects. For usage and installation instructions, visit their website. To integrate Alamofire into your Xcode project using CocoaPods, specify it in your `Podfile`:
+
+```ruby
+pod 'Alamofire', '~> 5.4'
+```
+
+### Carthage
+
+[Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks. To integrate Alamofire into your Xcode project using Carthage, specify it in your `Cartfile`:
+
+```ogdl
+github "Alamofire/Alamofire" ~> 5.4
+```
+
+### Swift Package Manager
+
+The [Swift Package Manager](https://swift.org/package-manager/) is a tool for automating the distribution of Swift code and is integrated into the `swift` compiler. It is in early development, but Alamofire does support its use on supported platforms.
+
+Once you have your Swift package set up, adding Alamofire as a dependency is as easy as adding it to the `dependencies` value of your `Package.swift`.
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/Alamofire/Alamofire.git", .upToNextMajor(from: "5.4.0"))
+]
+```
+
+### Manually
+
+If you prefer not to use any of the aforementioned dependency managers, you can integrate Alamofire into your project manually.
+
+#### Embedded Framework
+
+- Open up Terminal, `cd` into your top-level project directory, and run the following command "if" your project is not initialized as a git repository:
+
+  ```bash
+  $ git init
+  ```
+
+- Add Alamofire as a git [submodule](https://git-scm.com/docs/git-submodule) by running the following command:
+
+  ```bash
+  $ git submodule add https://github.com/Alamofire/Alamofire.git
+  ```
+
+- Open the new `Alamofire` folder, and drag the `Alamofire.xcodeproj` into the Project Navigator of your application's Xcode project.
+
+    > It should appear nested underneath your application's blue project icon. Whether it is above or below all the other Xcode groups does not matter.
+
+- Select the `Alamofire.xcodeproj` in the Project Navigator and verify the deployment target matches that of your application target.
+- Next, select your application project in the Project Navigator (blue project icon) to navigate to the target configuration window and select the application target under the "Targets" heading in the sidebar.
+- In the tab bar at the top of that window, open the "General" panel.
+- Click on the `+` button under the "Embedded Binaries" section.
+- You will see two different `Alamofire.xcodeproj` folders each with two different versions of the `Alamofire.framework` nested inside a `Products` folder.
+
+    > It does not matter which `Products` folder you choose from, but it does matter whether you choose the top or bottom `Alamofire.framework`.
+
+- Select the top `Alamofire.framework` for iOS and the bottom one for macOS.
+
+    > You can verify which one you selected by inspecting the build log for your project. The build target for `Alamofire` will be listed as `Alamofire iOS`, `Alamofire macOS`, `Alamofire tvOS`, or `Alamofire watchOS`.
+
+- And that's it!
+
+  > The `Alamofire.framework` is automagically added as a target dependency, linked framework and embedded framework in a copy files build phase which is all you need to build on the simulator and a device.
+
+## Open Radars
+
+The following radars have some effect on the current implementation of Alamofire.
+
+- [`rdar://21349340`](http://www.openradar.me/radar?id=5517037090635776) - Compiler throwing warning due to toll-free bridging issue in the test case
+- `rdar://26870455` - Background URL Session Configurations do not work in the simulator
+- `rdar://26849668` - Some URLProtocol APIs do not properly handle `URLRequest`
+
+## Resolved Radars
+
+The following radars have been resolved over time after being filed against the Alamofire project.
+
+- [`rdar://26761490`](http://www.openradar.me/radar?id=5010235949318144) - Swift string interpolation causing memory leak with common usage.
+  - (Resolved): 9/1/17 in Xcode 9 beta 6.
+- [`rdar://36082113`](http://openradar.appspot.com/radar?id=4942308441063424) - `URLSessionTaskMetrics` failing to link on watchOS 3.0+
+  - (Resolved): Just add `CFNetwork` to your linked frameworks.
+- `FB7624529` - `urlSession(_:task:didFinishCollecting:)` never called on watchOS
+  - (Resolved): Metrics now collected on watchOS 7+.
+
+## FAQ
+
+### What's the origin of the name Alamofire?
+
+Alamofire is named after the [Alamo Fire flower](https://aggie-horticulture.tamu.edu/wildseed/alamofire.html), a hybrid variant of the Bluebonnet, the official state flower of Texas.
+
+## Credits
+
+Alamofire is owned and maintained by the [Alamofire Software Foundation](http://alamofire.org). You can follow them on Twitter at [@AlamofireSF](https://twitter.com/AlamofireSF) for project updates and releases.
+
+### Security Disclosure
+
+If you believe you have identified a security vulnerability with Alamofire, you should report it as soon as possible via email to security@alamofire.org. Please do not post it to a public issue tracker.
+
+## Donations
+
+The [ASF](https://github.com/Alamofire/Foundation#members) is looking to raise money to officially stay registered as a federal non-profit organization.
+Registering will allow Foundation members to gain some legal protections and also allow us to put donations to use, tax-free.
+Donating to the ASF will enable us to:
+
+- Pay our yearly legal fees to keep the non-profit in good status
+- Pay for our mail servers to help us stay on top of all questions and security issues
+- Potentially fund test servers to make it easier for us to test the edge cases
+- Potentially fund developers to work on one of our projects full-time
+
+The community adoption of the ASF libraries has been amazing.
+We are greatly humbled by your enthusiasm around the projects and want to continue to do everything we can to move the needle forward.
+With your continued support, the ASF will be able to improve its reach and also provide better legal safety for the core members.
+If you use any of our libraries for work, see if your employers would be interested in donating.
+Any amount you can donate today to help us reach our goal would be greatly appreciated.
+
+[![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W34WPEE74APJQ)
+
+## Supporters
+
+[MacStadium](https://macstadium.com) provides Alamofire with a free, hosted Mac mini.
+
+![Powered by MacStadium](https://raw.githubusercontent.com/Alamofire/Alamofire/master/Resources/MacStadiumLogo.png)
+
+## License
+
+Alamofire is released under the MIT license. [See LICENSE](https://github.com/Alamofire/Alamofire/blob/master/LICENSE) for details.

Pods/Alamofire/Source/AFError.swift

@@ -0,0 +1,870 @@
+//
+//  AFError.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// `AFError` is the error type returned by Alamofire. It encompasses a few different types of errors, each with
+/// their own associated reasons.
+public enum AFError: Error {
+    /// The underlying reason the `.multipartEncodingFailed` error occurred.
+    public enum MultipartEncodingFailureReason {
+        /// The `fileURL` provided for reading an encodable body part isn't a file `URL`.
+        case bodyPartURLInvalid(url: URL)
+        /// The filename of the `fileURL` provided has either an empty `lastPathComponent` or `pathExtension.
+        case bodyPartFilenameInvalid(in: URL)
+        /// The file at the `fileURL` provided was not reachable.
+        case bodyPartFileNotReachable(at: URL)
+        /// Attempting to check the reachability of the `fileURL` provided threw an error.
+        case bodyPartFileNotReachableWithError(atURL: URL, error: Error)
+        /// The file at the `fileURL` provided is actually a directory.
+        case bodyPartFileIsDirectory(at: URL)
+        /// The size of the file at the `fileURL` provided was not returned by the system.
+        case bodyPartFileSizeNotAvailable(at: URL)
+        /// The attempt to find the size of the file at the `fileURL` provided threw an error.
+        case bodyPartFileSizeQueryFailedWithError(forURL: URL, error: Error)
+        /// An `InputStream` could not be created for the provided `fileURL`.
+        case bodyPartInputStreamCreationFailed(for: URL)
+        /// An `OutputStream` could not be created when attempting to write the encoded data to disk.
+        case outputStreamCreationFailed(for: URL)
+        /// The encoded body data could not be written to disk because a file already exists at the provided `fileURL`.
+        case outputStreamFileAlreadyExists(at: URL)
+        /// The `fileURL` provided for writing the encoded body data to disk is not a file `URL`.
+        case outputStreamURLInvalid(url: URL)
+        /// The attempt to write the encoded body data to disk failed with an underlying error.
+        case outputStreamWriteFailed(error: Error)
+        /// The attempt to read an encoded body part `InputStream` failed with underlying system error.
+        case inputStreamReadFailed(error: Error)
+    }
+
+    /// Represents unexpected input stream length that occur when encoding the `MultipartFormData`. Instances will be
+    /// embedded within an `AFError.multipartEncodingFailed` `.inputStreamReadFailed` case.
+    public struct UnexpectedInputStreamLength: Error {
+        /// The expected byte count to read.
+        public var bytesExpected: UInt64
+        /// The actual byte count read.
+        public var bytesRead: UInt64
+    }
+
+    /// The underlying reason the `.parameterEncodingFailed` error occurred.
+    public enum ParameterEncodingFailureReason {
+        /// The `URLRequest` did not have a `URL` to encode.
+        case missingURL
+        /// JSON serialization failed with an underlying system error during the encoding process.
+        case jsonEncodingFailed(error: Error)
+        /// Custom parameter encoding failed due to the associated `Error`.
+        case customEncodingFailed(error: Error)
+    }
+
+    /// The underlying reason the `.parameterEncoderFailed` error occurred.
+    public enum ParameterEncoderFailureReason {
+        /// Possible missing components.
+        public enum RequiredComponent {
+            /// The `URL` was missing or unable to be extracted from the passed `URLRequest` or during encoding.
+            case url
+            /// The `HTTPMethod` could not be extracted from the passed `URLRequest`.
+            case httpMethod(rawValue: String)
+        }
+
+        /// A `RequiredComponent` was missing during encoding.
+        case missingRequiredComponent(RequiredComponent)
+        /// The underlying encoder failed with the associated error.
+        case encoderFailed(error: Error)
+    }
+
+    /// The underlying reason the `.responseValidationFailed` error occurred.
+    public enum ResponseValidationFailureReason {
+        /// The data file containing the server response did not exist.
+        case dataFileNil
+        /// The data file containing the server response at the associated `URL` could not be read.
+        case dataFileReadFailed(at: URL)
+        /// The response did not contain a `Content-Type` and the `acceptableContentTypes` provided did not contain a
+        /// wildcard type.
+        case missingContentType(acceptableContentTypes: [String])
+        /// The response `Content-Type` did not match any type in the provided `acceptableContentTypes`.
+        case unacceptableContentType(acceptableContentTypes: [String], responseContentType: String)
+        /// The response status code was not acceptable.
+        case unacceptableStatusCode(code: Int)
+        /// Custom response validation failed due to the associated `Error`.
+        case customValidationFailed(error: Error)
+    }
+
+    /// The underlying reason the response serialization error occurred.
+    public enum ResponseSerializationFailureReason {
+        /// The server response contained no data or the data was zero length.
+        case inputDataNilOrZeroLength
+        /// The file containing the server response did not exist.
+        case inputFileNil
+        /// The file containing the server response could not be read from the associated `URL`.
+        case inputFileReadFailed(at: URL)
+        /// String serialization failed using the provided `String.Encoding`.
+        case stringSerializationFailed(encoding: String.Encoding)
+        /// JSON serialization failed with an underlying system error.
+        case jsonSerializationFailed(error: Error)
+        /// A `DataDecoder` failed to decode the response due to the associated `Error`.
+        case decodingFailed(error: Error)
+        /// A custom response serializer failed due to the associated `Error`.
+        case customSerializationFailed(error: Error)
+        /// Generic serialization failed for an empty response that wasn't type `Empty` but instead the associated type.
+        case invalidEmptyResponse(type: String)
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// Underlying reason a server trust evaluation error occurred.
+    public enum ServerTrustFailureReason {
+        /// The output of a server trust evaluation.
+        public struct Output {
+            /// The host for which the evaluation was performed.
+            public let host: String
+            /// The `SecTrust` value which was evaluated.
+            public let trust: SecTrust
+            /// The `OSStatus` of evaluation operation.
+            public let status: OSStatus
+            /// The result of the evaluation operation.
+            public let result: SecTrustResultType
+
+            /// Creates an `Output` value from the provided values.
+            init(_ host: String, _ trust: SecTrust, _ status: OSStatus, _ result: SecTrustResultType) {
+                self.host = host
+                self.trust = trust
+                self.status = status
+                self.result = result
+            }
+        }
+
+        /// No `ServerTrustEvaluator` was found for the associated host.
+        case noRequiredEvaluator(host: String)
+        /// No certificates were found with which to perform the trust evaluation.
+        case noCertificatesFound
+        /// No public keys were found with which to perform the trust evaluation.
+        case noPublicKeysFound
+        /// During evaluation, application of the associated `SecPolicy` failed.
+        case policyApplicationFailed(trust: SecTrust, policy: SecPolicy, status: OSStatus)
+        /// During evaluation, setting the associated anchor certificates failed.
+        case settingAnchorCertificatesFailed(status: OSStatus, certificates: [SecCertificate])
+        /// During evaluation, creation of the revocation policy failed.
+        case revocationPolicyCreationFailed
+        /// `SecTrust` evaluation failed with the associated `Error`, if one was produced.
+        case trustEvaluationFailed(error: Error?)
+        /// Default evaluation failed with the associated `Output`.
+        case defaultEvaluationFailed(output: Output)
+        /// Host validation failed with the associated `Output`.
+        case hostValidationFailed(output: Output)
+        /// Revocation check failed with the associated `Output` and options.
+        case revocationCheckFailed(output: Output, options: RevocationTrustEvaluator.Options)
+        /// Certificate pinning failed.
+        case certificatePinningFailed(host: String, trust: SecTrust, pinnedCertificates: [SecCertificate], serverCertificates: [SecCertificate])
+        /// Public key pinning failed.
+        case publicKeyPinningFailed(host: String, trust: SecTrust, pinnedKeys: [SecKey], serverKeys: [SecKey])
+        /// Custom server trust evaluation failed due to the associated `Error`.
+        case customEvaluationFailed(error: Error)
+    }
+    #endif
+
+    /// The underlying reason the `.urlRequestValidationFailed`
+    public enum URLRequestValidationFailureReason {
+        /// URLRequest with GET method had body data.
+        case bodyDataInGETRequest(Data)
+    }
+
+    ///  `UploadableConvertible` threw an error in `createUploadable()`.
+    case createUploadableFailed(error: Error)
+    ///  `URLRequestConvertible` threw an error in `asURLRequest()`.
+    case createURLRequestFailed(error: Error)
+    /// `SessionDelegate` threw an error while attempting to move downloaded file to destination URL.
+    case downloadedFileMoveFailed(error: Error, source: URL, destination: URL)
+    /// `Request` was explicitly cancelled.
+    case explicitlyCancelled
+    /// `URLConvertible` type failed to create a valid `URL`.
+    case invalidURL(url: URLConvertible)
+    /// Multipart form encoding failed.
+    case multipartEncodingFailed(reason: MultipartEncodingFailureReason)
+    /// `ParameterEncoding` threw an error during the encoding process.
+    case parameterEncodingFailed(reason: ParameterEncodingFailureReason)
+    /// `ParameterEncoder` threw an error while running the encoder.
+    case parameterEncoderFailed(reason: ParameterEncoderFailureReason)
+    /// `RequestAdapter` threw an error during adaptation.
+    case requestAdaptationFailed(error: Error)
+    /// `RequestRetrier` threw an error during the request retry process.
+    case requestRetryFailed(retryError: Error, originalError: Error)
+    /// Response validation failed.
+    case responseValidationFailed(reason: ResponseValidationFailureReason)
+    /// Response serialization failed.
+    case responseSerializationFailed(reason: ResponseSerializationFailureReason)
+    #if !(os(Linux) || os(Windows))
+    /// `ServerTrustEvaluating` instance threw an error during trust evaluation.
+    case serverTrustEvaluationFailed(reason: ServerTrustFailureReason)
+    #endif
+    /// `Session` which issued the `Request` was deinitialized, most likely because its reference went out of scope.
+    case sessionDeinitialized
+    /// `Session` was explicitly invalidated, possibly with the `Error` produced by the underlying `URLSession`.
+    case sessionInvalidated(error: Error?)
+    /// `URLSessionTask` completed with error.
+    case sessionTaskFailed(error: Error)
+    /// `URLRequest` failed validation.
+    case urlRequestValidationFailed(reason: URLRequestValidationFailureReason)
+}
+
+extension Error {
+    /// Returns the instance cast as an `AFError`.
+    public var asAFError: AFError? {
+        self as? AFError
+    }
+
+    /// Returns the instance cast as an `AFError`. If casting fails, a `fatalError` with the specified `message` is thrown.
+    public func asAFError(orFailWith message: @autoclosure () -> String, file: StaticString = #file, line: UInt = #line) -> AFError {
+        guard let afError = self as? AFError else {
+            fatalError(message(), file: file, line: line)
+        }
+        return afError
+    }
+
+    /// Casts the instance as `AFError` or returns `defaultAFError`
+    func asAFError(or defaultAFError: @autoclosure () -> AFError) -> AFError {
+        self as? AFError ?? defaultAFError()
+    }
+}
+
+// MARK: - Error Booleans
+
+extension AFError {
+    /// Returns whether the instance is `.sessionDeinitialized`.
+    public var isSessionDeinitializedError: Bool {
+        if case .sessionDeinitialized = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.sessionInvalidated`.
+    public var isSessionInvalidatedError: Bool {
+        if case .sessionInvalidated = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.explicitlyCancelled`.
+    public var isExplicitlyCancelledError: Bool {
+        if case .explicitlyCancelled = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.invalidURL`.
+    public var isInvalidURLError: Bool {
+        if case .invalidURL = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.parameterEncodingFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isParameterEncodingError: Bool {
+        if case .parameterEncodingFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.parameterEncoderFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isParameterEncoderError: Bool {
+        if case .parameterEncoderFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.multipartEncodingFailed`. When `true`, the `url` and `underlyingError`
+    /// properties will contain the associated values.
+    public var isMultipartEncodingError: Bool {
+        if case .multipartEncodingFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.requestAdaptationFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isRequestAdaptationError: Bool {
+        if case .requestAdaptationFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.responseValidationFailed`. When `true`, the `acceptableContentTypes`,
+    /// `responseContentType`,  `responseCode`, and `underlyingError` properties will contain the associated values.
+    public var isResponseValidationError: Bool {
+        if case .responseValidationFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `.responseSerializationFailed`. When `true`, the `failedStringEncoding` and
+    /// `underlyingError` properties will contain the associated values.
+    public var isResponseSerializationError: Bool {
+        if case .responseSerializationFailed = self { return true }
+        return false
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// Returns whether the instance is `.serverTrustEvaluationFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isServerTrustEvaluationError: Bool {
+        if case .serverTrustEvaluationFailed = self { return true }
+        return false
+    }
+    #endif
+
+    /// Returns whether the instance is `requestRetryFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isRequestRetryError: Bool {
+        if case .requestRetryFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `createUploadableFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isCreateUploadableError: Bool {
+        if case .createUploadableFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `createURLRequestFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isCreateURLRequestError: Bool {
+        if case .createURLRequestFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `downloadedFileMoveFailed`. When `true`, the `destination` and `underlyingError` properties will
+    /// contain the associated values.
+    public var isDownloadedFileMoveError: Bool {
+        if case .downloadedFileMoveFailed = self { return true }
+        return false
+    }
+
+    /// Returns whether the instance is `createURLRequestFailed`. When `true`, the `underlyingError` property will
+    /// contain the associated value.
+    public var isSessionTaskError: Bool {
+        if case .sessionTaskFailed = self { return true }
+        return false
+    }
+}
+
+// MARK: - Convenience Properties
+
+extension AFError {
+    /// The `URLConvertible` associated with the error.
+    public var urlConvertible: URLConvertible? {
+        guard case let .invalidURL(url) = self else { return nil }
+        return url
+    }
+
+    /// The `URL` associated with the error.
+    public var url: URL? {
+        guard case let .multipartEncodingFailed(reason) = self else { return nil }
+        return reason.url
+    }
+
+    /// The underlying `Error` responsible for generating the failure associated with `.sessionInvalidated`,
+    /// `.parameterEncodingFailed`, `.parameterEncoderFailed`, `.multipartEncodingFailed`, `.requestAdaptationFailed`,
+    /// `.responseSerializationFailed`, `.requestRetryFailed` errors.
+    public var underlyingError: Error? {
+        switch self {
+        case let .multipartEncodingFailed(reason):
+            return reason.underlyingError
+        case let .parameterEncodingFailed(reason):
+            return reason.underlyingError
+        case let .parameterEncoderFailed(reason):
+            return reason.underlyingError
+        case let .requestAdaptationFailed(error):
+            return error
+        case let .requestRetryFailed(retryError, _):
+            return retryError
+        case let .responseValidationFailed(reason):
+            return reason.underlyingError
+        case let .responseSerializationFailed(reason):
+            return reason.underlyingError
+        #if !(os(Linux) || os(Windows))
+        case let .serverTrustEvaluationFailed(reason):
+            return reason.underlyingError
+        #endif
+        case let .sessionInvalidated(error):
+            return error
+        case let .createUploadableFailed(error):
+            return error
+        case let .createURLRequestFailed(error):
+            return error
+        case let .downloadedFileMoveFailed(error, _, _):
+            return error
+        case let .sessionTaskFailed(error):
+            return error
+        case .explicitlyCancelled,
+             .invalidURL,
+             .sessionDeinitialized,
+             .urlRequestValidationFailed:
+            return nil
+        }
+    }
+
+    /// The acceptable `Content-Type`s of a `.responseValidationFailed` error.
+    public var acceptableContentTypes: [String]? {
+        guard case let .responseValidationFailed(reason) = self else { return nil }
+        return reason.acceptableContentTypes
+    }
+
+    /// The response `Content-Type` of a `.responseValidationFailed` error.
+    public var responseContentType: String? {
+        guard case let .responseValidationFailed(reason) = self else { return nil }
+        return reason.responseContentType
+    }
+
+    /// The response code of a `.responseValidationFailed` error.
+    public var responseCode: Int? {
+        guard case let .responseValidationFailed(reason) = self else { return nil }
+        return reason.responseCode
+    }
+
+    /// The `String.Encoding` associated with a failed `.stringResponse()` call.
+    public var failedStringEncoding: String.Encoding? {
+        guard case let .responseSerializationFailed(reason) = self else { return nil }
+        return reason.failedStringEncoding
+    }
+
+    /// The `source` URL of a `.downloadedFileMoveFailed` error.
+    public var sourceURL: URL? {
+        guard case let .downloadedFileMoveFailed(_, source, _) = self else { return nil }
+        return source
+    }
+
+    /// The `destination` URL of a `.downloadedFileMoveFailed` error.
+    public var destinationURL: URL? {
+        guard case let .downloadedFileMoveFailed(_, _, destination) = self else { return nil }
+        return destination
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// The download resume data of any underlying network error. Only produced by `DownloadRequest`s.
+    public var downloadResumeData: Data? {
+        (underlyingError as? URLError)?.userInfo[NSURLSessionDownloadTaskResumeData] as? Data
+    }
+    #endif
+}
+
+extension AFError.ParameterEncodingFailureReason {
+    var underlyingError: Error? {
+        switch self {
+        case let .jsonEncodingFailed(error),
+             let .customEncodingFailed(error):
+            return error
+        case .missingURL:
+            return nil
+        }
+    }
+}
+
+extension AFError.ParameterEncoderFailureReason {
+    var underlyingError: Error? {
+        switch self {
+        case let .encoderFailed(error):
+            return error
+        case .missingRequiredComponent:
+            return nil
+        }
+    }
+}
+
+extension AFError.MultipartEncodingFailureReason {
+    var url: URL? {
+        switch self {
+        case let .bodyPartURLInvalid(url),
+             let .bodyPartFilenameInvalid(url),
+             let .bodyPartFileNotReachable(url),
+             let .bodyPartFileIsDirectory(url),
+             let .bodyPartFileSizeNotAvailable(url),
+             let .bodyPartInputStreamCreationFailed(url),
+             let .outputStreamCreationFailed(url),
+             let .outputStreamFileAlreadyExists(url),
+             let .outputStreamURLInvalid(url),
+             let .bodyPartFileNotReachableWithError(url, _),
+             let .bodyPartFileSizeQueryFailedWithError(url, _):
+            return url
+        case .outputStreamWriteFailed,
+             .inputStreamReadFailed:
+            return nil
+        }
+    }
+
+    var underlyingError: Error? {
+        switch self {
+        case let .bodyPartFileNotReachableWithError(_, error),
+             let .bodyPartFileSizeQueryFailedWithError(_, error),
+             let .outputStreamWriteFailed(error),
+             let .inputStreamReadFailed(error):
+            return error
+        case .bodyPartURLInvalid,
+             .bodyPartFilenameInvalid,
+             .bodyPartFileNotReachable,
+             .bodyPartFileIsDirectory,
+             .bodyPartFileSizeNotAvailable,
+             .bodyPartInputStreamCreationFailed,
+             .outputStreamCreationFailed,
+             .outputStreamFileAlreadyExists,
+             .outputStreamURLInvalid:
+            return nil
+        }
+    }
+}
+
+extension AFError.ResponseValidationFailureReason {
+    var acceptableContentTypes: [String]? {
+        switch self {
+        case let .missingContentType(types),
+             let .unacceptableContentType(types, _):
+            return types
+        case .dataFileNil,
+             .dataFileReadFailed,
+             .unacceptableStatusCode,
+             .customValidationFailed:
+            return nil
+        }
+    }
+
+    var responseContentType: String? {
+        switch self {
+        case let .unacceptableContentType(_, responseType):
+            return responseType
+        case .dataFileNil,
+             .dataFileReadFailed,
+             .missingContentType,
+             .unacceptableStatusCode,
+             .customValidationFailed:
+            return nil
+        }
+    }
+
+    var responseCode: Int? {
+        switch self {
+        case let .unacceptableStatusCode(code):
+            return code
+        case .dataFileNil,
+             .dataFileReadFailed,
+             .missingContentType,
+             .unacceptableContentType,
+             .customValidationFailed:
+            return nil
+        }
+    }
+
+    var underlyingError: Error? {
+        switch self {
+        case let .customValidationFailed(error):
+            return error
+        case .dataFileNil,
+             .dataFileReadFailed,
+             .missingContentType,
+             .unacceptableContentType,
+             .unacceptableStatusCode:
+            return nil
+        }
+    }
+}
+
+extension AFError.ResponseSerializationFailureReason {
+    var failedStringEncoding: String.Encoding? {
+        switch self {
+        case let .stringSerializationFailed(encoding):
+            return encoding
+        case .inputDataNilOrZeroLength,
+             .inputFileNil,
+             .inputFileReadFailed(_),
+             .jsonSerializationFailed(_),
+             .decodingFailed(_),
+             .customSerializationFailed(_),
+             .invalidEmptyResponse:
+            return nil
+        }
+    }
+
+    var underlyingError: Error? {
+        switch self {
+        case let .jsonSerializationFailed(error),
+             let .decodingFailed(error),
+             let .customSerializationFailed(error):
+            return error
+        case .inputDataNilOrZeroLength,
+             .inputFileNil,
+             .inputFileReadFailed,
+             .stringSerializationFailed,
+             .invalidEmptyResponse:
+            return nil
+        }
+    }
+}
+
+#if !(os(Linux) || os(Windows))
+extension AFError.ServerTrustFailureReason {
+    var output: AFError.ServerTrustFailureReason.Output? {
+        switch self {
+        case let .defaultEvaluationFailed(output),
+             let .hostValidationFailed(output),
+             let .revocationCheckFailed(output, _):
+            return output
+        case .noRequiredEvaluator,
+             .noCertificatesFound,
+             .noPublicKeysFound,
+             .policyApplicationFailed,
+             .settingAnchorCertificatesFailed,
+             .revocationPolicyCreationFailed,
+             .trustEvaluationFailed,
+             .certificatePinningFailed,
+             .publicKeyPinningFailed,
+             .customEvaluationFailed:
+            return nil
+        }
+    }
+
+    var underlyingError: Error? {
+        switch self {
+        case let .customEvaluationFailed(error):
+            return error
+        case let .trustEvaluationFailed(error):
+            return error
+        case .noRequiredEvaluator,
+             .noCertificatesFound,
+             .noPublicKeysFound,
+             .policyApplicationFailed,
+             .settingAnchorCertificatesFailed,
+             .revocationPolicyCreationFailed,
+             .defaultEvaluationFailed,
+             .hostValidationFailed,
+             .revocationCheckFailed,
+             .certificatePinningFailed,
+             .publicKeyPinningFailed:
+            return nil
+        }
+    }
+}
+#endif
+
+// MARK: - Error Descriptions
+
+extension AFError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .explicitlyCancelled:
+            return "Request explicitly cancelled."
+        case let .invalidURL(url):
+            return "URL is not valid: \(url)"
+        case let .parameterEncodingFailed(reason):
+            return reason.localizedDescription
+        case let .parameterEncoderFailed(reason):
+            return reason.localizedDescription
+        case let .multipartEncodingFailed(reason):
+            return reason.localizedDescription
+        case let .requestAdaptationFailed(error):
+            return "Request adaption failed with error: \(error.localizedDescription)"
+        case let .responseValidationFailed(reason):
+            return reason.localizedDescription
+        case let .responseSerializationFailed(reason):
+            return reason.localizedDescription
+        case let .requestRetryFailed(retryError, originalError):
+            return """
+            Request retry failed with retry error: \(retryError.localizedDescription), \
+            original error: \(originalError.localizedDescription)
+            """
+        case .sessionDeinitialized:
+            return """
+            Session was invalidated without error, so it was likely deinitialized unexpectedly. \
+            Be sure to retain a reference to your Session for the duration of your requests.
+            """
+        case let .sessionInvalidated(error):
+            return "Session was invalidated with error: \(error?.localizedDescription ?? "No description.")"
+        #if !(os(Linux) || os(Windows))
+        case let .serverTrustEvaluationFailed(reason):
+            return "Server trust evaluation failed due to reason: \(reason.localizedDescription)"
+        #endif
+        case let .urlRequestValidationFailed(reason):
+            return "URLRequest validation failed due to reason: \(reason.localizedDescription)"
+        case let .createUploadableFailed(error):
+            return "Uploadable creation failed with error: \(error.localizedDescription)"
+        case let .createURLRequestFailed(error):
+            return "URLRequest creation failed with error: \(error.localizedDescription)"
+        case let .downloadedFileMoveFailed(error, source, destination):
+            return "Moving downloaded file from: \(source) to: \(destination) failed with error: \(error.localizedDescription)"
+        case let .sessionTaskFailed(error):
+            return "URLSessionTask failed with error: \(error.localizedDescription)"
+        }
+    }
+}
+
+extension AFError.ParameterEncodingFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case .missingURL:
+            return "URL request to encode was missing a URL"
+        case let .jsonEncodingFailed(error):
+            return "JSON could not be encoded because of error:\n\(error.localizedDescription)"
+        case let .customEncodingFailed(error):
+            return "Custom parameter encoder failed with error: \(error.localizedDescription)"
+        }
+    }
+}
+
+extension AFError.ParameterEncoderFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case let .missingRequiredComponent(component):
+            return "Encoding failed due to a missing request component: \(component)"
+        case let .encoderFailed(error):
+            return "The underlying encoder failed with the error: \(error)"
+        }
+    }
+}
+
+extension AFError.MultipartEncodingFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case let .bodyPartURLInvalid(url):
+            return "The URL provided is not a file URL: \(url)"
+        case let .bodyPartFilenameInvalid(url):
+            return "The URL provided does not have a valid filename: \(url)"
+        case let .bodyPartFileNotReachable(url):
+            return "The URL provided is not reachable: \(url)"
+        case let .bodyPartFileNotReachableWithError(url, error):
+            return """
+            The system returned an error while checking the provided URL for reachability.
+            URL: \(url)
+            Error: \(error)
+            """
+        case let .bodyPartFileIsDirectory(url):
+            return "The URL provided is a directory: \(url)"
+        case let .bodyPartFileSizeNotAvailable(url):
+            return "Could not fetch the file size from the provided URL: \(url)"
+        case let .bodyPartFileSizeQueryFailedWithError(url, error):
+            return """
+            The system returned an error while attempting to fetch the file size from the provided URL.
+            URL: \(url)
+            Error: \(error)
+            """
+        case let .bodyPartInputStreamCreationFailed(url):
+            return "Failed to create an InputStream for the provided URL: \(url)"
+        case let .outputStreamCreationFailed(url):
+            return "Failed to create an OutputStream for URL: \(url)"
+        case let .outputStreamFileAlreadyExists(url):
+            return "A file already exists at the provided URL: \(url)"
+        case let .outputStreamURLInvalid(url):
+            return "The provided OutputStream URL is invalid: \(url)"
+        case let .outputStreamWriteFailed(error):
+            return "OutputStream write failed with error: \(error)"
+        case let .inputStreamReadFailed(error):
+            return "InputStream read failed with error: \(error)"
+        }
+    }
+}
+
+extension AFError.ResponseSerializationFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case .inputDataNilOrZeroLength:
+            return "Response could not be serialized, input data was nil or zero length."
+        case .inputFileNil:
+            return "Response could not be serialized, input file was nil."
+        case let .inputFileReadFailed(url):
+            return "Response could not be serialized, input file could not be read: \(url)."
+        case let .stringSerializationFailed(encoding):
+            return "String could not be serialized with encoding: \(encoding)."
+        case let .jsonSerializationFailed(error):
+            return "JSON could not be serialized because of error:\n\(error.localizedDescription)"
+        case let .invalidEmptyResponse(type):
+            return """
+            Empty response could not be serialized to type: \(type). \
+            Use Empty as the expected type for such responses.
+            """
+        case let .decodingFailed(error):
+            return "Response could not be decoded because of error:\n\(error.localizedDescription)"
+        case let .customSerializationFailed(error):
+            return "Custom response serializer failed with error:\n\(error.localizedDescription)"
+        }
+    }
+}
+
+extension AFError.ResponseValidationFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case .dataFileNil:
+            return "Response could not be validated, data file was nil."
+        case let .dataFileReadFailed(url):
+            return "Response could not be validated, data file could not be read: \(url)."
+        case let .missingContentType(types):
+            return """
+            Response Content-Type was missing and acceptable content types \
+            (\(types.joined(separator: ","))) do not match "*/*".
+            """
+        case let .unacceptableContentType(acceptableTypes, responseType):
+            return """
+            Response Content-Type "\(responseType)" does not match any acceptable types: \
+            \(acceptableTypes.joined(separator: ",")).
+            """
+        case let .unacceptableStatusCode(code):
+            return "Response status code was unacceptable: \(code)."
+        case let .customValidationFailed(error):
+            return "Custom response validation failed with error: \(error.localizedDescription)"
+        }
+    }
+}
+
+#if !(os(Linux) || os(Windows))
+extension AFError.ServerTrustFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case let .noRequiredEvaluator(host):
+            return "A ServerTrustEvaluating value is required for host \(host) but none was found."
+        case .noCertificatesFound:
+            return "No certificates were found or provided for evaluation."
+        case .noPublicKeysFound:
+            return "No public keys were found or provided for evaluation."
+        case .policyApplicationFailed:
+            return "Attempting to set a SecPolicy failed."
+        case .settingAnchorCertificatesFailed:
+            return "Attempting to set the provided certificates as anchor certificates failed."
+        case .revocationPolicyCreationFailed:
+            return "Attempting to create a revocation policy failed."
+        case let .trustEvaluationFailed(error):
+            return "SecTrust evaluation failed with error: \(error?.localizedDescription ?? "None")"
+        case let .defaultEvaluationFailed(output):
+            return "Default evaluation failed for host \(output.host)."
+        case let .hostValidationFailed(output):
+            return "Host validation failed for host \(output.host)."
+        case let .revocationCheckFailed(output, _):
+            return "Revocation check failed for host \(output.host)."
+        case let .certificatePinningFailed(host, _, _, _):
+            return "Certificate pinning failed for host \(host)."
+        case let .publicKeyPinningFailed(host, _, _, _):
+            return "Public key pinning failed for host \(host)."
+        case let .customEvaluationFailed(error):
+            return "Custom trust evaluation failed with error: \(error.localizedDescription)"
+        }
+    }
+}
+#endif
+
+extension AFError.URLRequestValidationFailureReason {
+    var localizedDescription: String {
+        switch self {
+        case let .bodyDataInGETRequest(data):
+            return """
+            Invalid URLRequest: Requests with GET method cannot have body data:
+            \(String(decoding: data, as: UTF8.self))
+            """
+        }
+    }
+}

Pods/Alamofire/Source/Alamofire.swift

@@ -0,0 +1,35 @@
+//
+//  Alamofire.swift
+//
+//  Copyright (c) 2014-2021 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Dispatch
+import Foundation
+#if canImport(FoundationNetworking)
+@_exported import FoundationNetworking
+#endif
+
+/// Reference to `Session.default` for quick bootstrapping and examples.
+public let AF = Session.default
+
+/// Current Alamofire version. Necessary since SPM doesn't use dynamic libraries. Plus this will be more accurate.
+let version = "5.4.4"

Pods/Alamofire/Source/AlamofireExtended.swift

@@ -0,0 +1,61 @@
+//
+//  AlamofireExtended.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+/// Type that acts as a generic extension point for all `AlamofireExtended` types.
+public struct AlamofireExtension<ExtendedType> {
+    /// Stores the type or meta-type of any extended type.
+    public private(set) var type: ExtendedType
+
+    /// Create an instance from the provided value.
+    ///
+    /// - Parameter type: Instance being extended.
+    public init(_ type: ExtendedType) {
+        self.type = type
+    }
+}
+
+/// Protocol describing the `af` extension points for Alamofire extended types.
+public protocol AlamofireExtended {
+    /// Type being extended.
+    associatedtype ExtendedType
+
+    /// Static Alamofire extension point.
+    static var af: AlamofireExtension<ExtendedType>.Type { get set }
+    /// Instance Alamofire extension point.
+    var af: AlamofireExtension<ExtendedType> { get set }
+}
+
+extension AlamofireExtended {
+    /// Static Alamofire extension point.
+    public static var af: AlamofireExtension<Self>.Type {
+        get { AlamofireExtension<Self>.self }
+        set {}
+    }
+
+    /// Instance Alamofire extension point.
+    public var af: AlamofireExtension<Self> {
+        get { AlamofireExtension(self) }
+        set {}
+    }
+}

Pods/Alamofire/Source/AuthenticationInterceptor.swift

@@ -0,0 +1,404 @@
+//
+//  AuthenticationInterceptor.swift
+//
+//  Copyright (c) 2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Types adopting the `AuthenticationCredential` protocol can be used to authenticate `URLRequest`s.
+///
+/// One common example of an `AuthenticationCredential` is an OAuth2 credential containing an access token used to
+/// authenticate all requests on behalf of a user. The access token generally has an expiration window of 60 minutes
+/// which will then require a refresh of the credential using the refresh token to generate a new access token.
+public protocol AuthenticationCredential {
+    /// Whether the credential requires a refresh. This property should always return `true` when the credential is
+    /// expired. It is also wise to consider returning `true` when the credential will expire in several seconds or
+    /// minutes depending on the expiration window of the credential.
+    ///
+    /// For example, if the credential is valid for 60 minutes, then it would be wise to return `true` when the
+    /// credential is only valid for 5 minutes or less. That ensures the credential will not expire as it is passed
+    /// around backend services.
+    var requiresRefresh: Bool { get }
+}
+
+// MARK: -
+
+/// Types adopting the `Authenticator` protocol can be used to authenticate `URLRequest`s with an
+/// `AuthenticationCredential` as well as refresh the `AuthenticationCredential` when required.
+public protocol Authenticator: AnyObject {
+    /// The type of credential associated with the `Authenticator` instance.
+    associatedtype Credential: AuthenticationCredential
+
+    /// Applies the `Credential` to the `URLRequest`.
+    ///
+    /// In the case of OAuth2, the access token of the `Credential` would be added to the `URLRequest` as a Bearer
+    /// token to the `Authorization` header.
+    ///
+    /// - Parameters:
+    ///   - credential: The `Credential`.
+    ///   - urlRequest: The `URLRequest`.
+    func apply(_ credential: Credential, to urlRequest: inout URLRequest)
+
+    /// Refreshes the `Credential` and executes the `completion` closure with the `Result` once complete.
+    ///
+    /// Refresh can be called in one of two ways. It can be called before the `Request` is actually executed due to
+    /// a `requiresRefresh` returning `true` during the adapt portion of the `Request` creation process. It can also
+    /// be triggered by a failed `Request` where the authentication server denied access due to an expired or
+    /// invalidated access token.
+    ///
+    /// In the case of OAuth2, this method would use the refresh token of the `Credential` to generate a new
+    /// `Credential` using the authentication service. Once complete, the `completion` closure should be called with
+    /// the new `Credential`, or the error that occurred.
+    ///
+    /// In general, if the refresh call fails with certain status codes from the authentication server (commonly a 401),
+    /// the refresh token in the `Credential` can no longer be used to generate a valid `Credential`. In these cases,
+    /// you will need to reauthenticate the user with their username / password.
+    ///
+    /// Please note, these are just general examples of common use cases. They are not meant to solve your specific
+    /// authentication server challenges. Please work with your authentication server team to ensure your
+    /// `Authenticator` logic matches their expectations.
+    ///
+    /// - Parameters:
+    ///   - credential: The `Credential` to refresh.
+    ///   - session:    The `Session` requiring the refresh.
+    ///   - completion: The closure to be executed once the refresh is complete.
+    func refresh(_ credential: Credential, for session: Session, completion: @escaping (Result<Credential, Error>) -> Void)
+
+    /// Determines whether the `URLRequest` failed due to an authentication error based on the `HTTPURLResponse`.
+    ///
+    /// If the authentication server **CANNOT** invalidate credentials after they are issued, then simply return `false`
+    /// for this method. If the authentication server **CAN** invalidate credentials due to security breaches, then you
+    /// will need to work with your authentication server team to understand how to identify when this occurs.
+    ///
+    /// In the case of OAuth2, where an authentication server can invalidate credentials, you will need to inspect the
+    /// `HTTPURLResponse` or possibly the `Error` for when this occurs. This is commonly handled by the authentication
+    /// server returning a 401 status code and some additional header to indicate an OAuth2 failure occurred.
+    ///
+    /// It is very important to understand how your authentication server works to be able to implement this correctly.
+    /// For example, if your authentication server returns a 401 when an OAuth2 error occurs, and your downstream
+    /// service also returns a 401 when you are not authorized to perform that operation, how do you know which layer
+    /// of the backend returned you a 401? You do not want to trigger a refresh unless you know your authentication
+    /// server is actually the layer rejecting the request. Again, work with your authentication server team to understand
+    /// how to identify an OAuth2 401 error vs. a downstream 401 error to avoid endless refresh loops.
+    ///
+    /// - Parameters:
+    ///   - urlRequest: The `URLRequest`.
+    ///   - response:   The `HTTPURLResponse`.
+    ///   - error:      The `Error`.
+    ///
+    /// - Returns: `true` if the `URLRequest` failed due to an authentication error, `false` otherwise.
+    func didRequest(_ urlRequest: URLRequest, with response: HTTPURLResponse, failDueToAuthenticationError error: Error) -> Bool
+
+    /// Determines whether the `URLRequest` is authenticated with the `Credential`.
+    ///
+    /// If the authentication server **CANNOT** invalidate credentials after they are issued, then simply return `true`
+    /// for this method. If the authentication server **CAN** invalidate credentials due to security breaches, then
+    /// read on.
+    ///
+    /// When an authentication server can invalidate credentials, it means that you may have a non-expired credential
+    /// that appears to be valid, but will be rejected by the authentication server when used. Generally when this
+    /// happens, a number of requests are all sent when the application is foregrounded, and all of them will be
+    /// rejected by the authentication server in the order they are received. The first failed request will trigger a
+    /// refresh internally, which will update the credential, and then retry all the queued requests with the new
+    /// credential. However, it is possible that some of the original requests will not return from the authentication
+    /// server until the refresh has completed. This is where this method comes in.
+    ///
+    /// When the authentication server rejects a credential, we need to check to make sure we haven't refreshed the
+    /// credential while the request was in flight. If it has already refreshed, then we don't need to trigger an
+    /// additional refresh. If it hasn't refreshed, then we need to refresh.
+    ///
+    /// Now that it is understood how the result of this method is used in the refresh lifecyle, let's walk through how
+    /// to implement it. You should return `true` in this method if the `URLRequest` is authenticated in a way that
+    /// matches the values in the `Credential`. In the case of OAuth2, this would mean that the Bearer token in the
+    /// `Authorization` header of the `URLRequest` matches the access token in the `Credential`. If it matches, then we
+    /// know the `Credential` was used to authenticate the `URLRequest` and should return `true`. If the Bearer token
+    /// did not match the access token, then you should return `false`.
+    ///
+    /// - Parameters:
+    ///   - urlRequest: The `URLRequest`.
+    ///   - credential: The `Credential`.
+    ///
+    /// - Returns: `true` if the `URLRequest` is authenticated with the `Credential`, `false` otherwise.
+    func isRequest(_ urlRequest: URLRequest, authenticatedWith credential: Credential) -> Bool
+}
+
+// MARK: -
+
+/// Represents various authentication failures that occur when using the `AuthenticationInterceptor`. All errors are
+/// still vended from Alamofire as `AFError` types. The `AuthenticationError` instances will be embedded within
+/// `AFError` `.requestAdaptationFailed` or `.requestRetryFailed` cases.
+public enum AuthenticationError: Error {
+    /// The credential was missing so the request could not be authenticated.
+    case missingCredential
+    /// The credential was refreshed too many times within the `RefreshWindow`.
+    case excessiveRefresh
+}
+
+// MARK: -
+
+/// The `AuthenticationInterceptor` class manages the queuing and threading complexity of authenticating requests.
+/// It relies on an `Authenticator` type to handle the actual `URLRequest` authentication and `Credential` refresh.
+public class AuthenticationInterceptor<AuthenticatorType>: RequestInterceptor where AuthenticatorType: Authenticator {
+    // MARK: Typealiases
+
+    /// Type of credential used to authenticate requests.
+    public typealias Credential = AuthenticatorType.Credential
+
+    // MARK: Helper Types
+
+    /// Type that defines a time window used to identify excessive refresh calls. When enabled, prior to executing a
+    /// refresh, the `AuthenticationInterceptor` compares the timestamp history of previous refresh calls against the
+    /// `RefreshWindow`. If more refreshes have occurred within the refresh window than allowed, the refresh is
+    /// cancelled and an `AuthorizationError.excessiveRefresh` error is thrown.
+    public struct RefreshWindow {
+        /// `TimeInterval` defining the duration of the time window before the current time in which the number of
+        /// refresh attempts is compared against `maximumAttempts`. For example, if `interval` is 30 seconds, then the
+        /// `RefreshWindow` represents the past 30 seconds. If more attempts occurred in the past 30 seconds than
+        /// `maximumAttempts`, an `.excessiveRefresh` error will be thrown.
+        public let interval: TimeInterval
+
+        /// Total refresh attempts allowed within `interval` before throwing an `.excessiveRefresh` error.
+        public let maximumAttempts: Int
+
+        /// Creates a `RefreshWindow` instance from the specified `interval` and `maximumAttempts`.
+        ///
+        /// - Parameters:
+        ///   - interval:        `TimeInterval` defining the duration of the time window before the current time.
+        ///   - maximumAttempts: The maximum attempts allowed within the `TimeInterval`.
+        public init(interval: TimeInterval = 30.0, maximumAttempts: Int = 5) {
+            self.interval = interval
+            self.maximumAttempts = maximumAttempts
+        }
+    }
+
+    private struct AdaptOperation {
+        let urlRequest: URLRequest
+        let session: Session
+        let completion: (Result<URLRequest, Error>) -> Void
+    }
+
+    private enum AdaptResult {
+        case adapt(Credential)
+        case doNotAdapt(AuthenticationError)
+        case adaptDeferred
+    }
+
+    private struct MutableState {
+        var credential: Credential?
+
+        var isRefreshing = false
+        var refreshTimestamps: [TimeInterval] = []
+        var refreshWindow: RefreshWindow?
+
+        var adaptOperations: [AdaptOperation] = []
+        var requestsToRetry: [(RetryResult) -> Void] = []
+    }
+
+    // MARK: Properties
+
+    /// The `Credential` used to authenticate requests.
+    public var credential: Credential? {
+        get { mutableState.credential }
+        set { mutableState.credential = newValue }
+    }
+
+    let authenticator: AuthenticatorType
+    let queue = DispatchQueue(label: "org.alamofire.authentication.inspector")
+
+    @Protected
+    private var mutableState = MutableState()
+
+    // MARK: Initialization
+
+    /// Creates an `AuthenticationInterceptor` instance from the specified parameters.
+    ///
+    /// A `nil` `RefreshWindow` will result in the `AuthenticationInterceptor` not checking for excessive refresh calls.
+    /// It is recommended to always use a `RefreshWindow` to avoid endless refresh cycles.
+    ///
+    /// - Parameters:
+    ///   - authenticator: The `Authenticator` type.
+    ///   - credential:    The `Credential` if it exists. `nil` by default.
+    ///   - refreshWindow: The `RefreshWindow` used to identify excessive refresh calls. `RefreshWindow()` by default.
+    public init(authenticator: AuthenticatorType,
+                credential: Credential? = nil,
+                refreshWindow: RefreshWindow? = RefreshWindow()) {
+        self.authenticator = authenticator
+        mutableState.credential = credential
+        mutableState.refreshWindow = refreshWindow
+    }
+
+    // MARK: Adapt
+
+    public func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
+        let adaptResult: AdaptResult = $mutableState.write { mutableState in
+            // Queue the adapt operation if a refresh is already in place.
+            guard !mutableState.isRefreshing else {
+                let operation = AdaptOperation(urlRequest: urlRequest, session: session, completion: completion)
+                mutableState.adaptOperations.append(operation)
+                return .adaptDeferred
+            }
+
+            // Throw missing credential error is the credential is missing.
+            guard let credential = mutableState.credential else {
+                let error = AuthenticationError.missingCredential
+                return .doNotAdapt(error)
+            }
+
+            // Queue the adapt operation and trigger refresh operation if credential requires refresh.
+            guard !credential.requiresRefresh else {
+                let operation = AdaptOperation(urlRequest: urlRequest, session: session, completion: completion)
+                mutableState.adaptOperations.append(operation)
+                refresh(credential, for: session, insideLock: &mutableState)
+                return .adaptDeferred
+            }
+
+            return .adapt(credential)
+        }
+
+        switch adaptResult {
+        case let .adapt(credential):
+            var authenticatedRequest = urlRequest
+            authenticator.apply(credential, to: &authenticatedRequest)
+            completion(.success(authenticatedRequest))
+
+        case let .doNotAdapt(adaptError):
+            completion(.failure(adaptError))
+
+        case .adaptDeferred:
+            // No-op: adapt operation captured during refresh.
+            break
+        }
+    }
+
+    // MARK: Retry
+
+    public func retry(_ request: Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void) {
+        // Do not attempt retry if there was not an original request and response from the server.
+        guard let urlRequest = request.request, let response = request.response else {
+            completion(.doNotRetry)
+            return
+        }
+
+        // Do not attempt retry unless the `Authenticator` verifies failure was due to authentication error (i.e. 401 status code).
+        guard authenticator.didRequest(urlRequest, with: response, failDueToAuthenticationError: error) else {
+            completion(.doNotRetry)
+            return
+        }
+
+        // Do not attempt retry if there is no credential.
+        guard let credential = credential else {
+            let error = AuthenticationError.missingCredential
+            completion(.doNotRetryWithError(error))
+            return
+        }
+
+        // Retry the request if the `Authenticator` verifies it was authenticated with a previous credential.
+        guard authenticator.isRequest(urlRequest, authenticatedWith: credential) else {
+            completion(.retry)
+            return
+        }
+
+        $mutableState.write { mutableState in
+            mutableState.requestsToRetry.append(completion)
+
+            guard !mutableState.isRefreshing else { return }
+
+            refresh(credential, for: session, insideLock: &mutableState)
+        }
+    }
+
+    // MARK: Refresh
+
+    private func refresh(_ credential: Credential, for session: Session, insideLock mutableState: inout MutableState) {
+        guard !isRefreshExcessive(insideLock: &mutableState) else {
+            let error = AuthenticationError.excessiveRefresh
+            handleRefreshFailure(error, insideLock: &mutableState)
+            return
+        }
+
+        mutableState.refreshTimestamps.append(ProcessInfo.processInfo.systemUptime)
+        mutableState.isRefreshing = true
+
+        // Dispatch to queue to hop out of the lock in case authenticator.refresh is implemented synchronously.
+        queue.async {
+            self.authenticator.refresh(credential, for: session) { result in
+                self.$mutableState.write { mutableState in
+                    switch result {
+                    case let .success(credential):
+                        self.handleRefreshSuccess(credential, insideLock: &mutableState)
+                    case let .failure(error):
+                        self.handleRefreshFailure(error, insideLock: &mutableState)
+                    }
+                }
+            }
+        }
+    }
+
+    private func isRefreshExcessive(insideLock mutableState: inout MutableState) -> Bool {
+        guard let refreshWindow = mutableState.refreshWindow else { return false }
+
+        let refreshWindowMin = ProcessInfo.processInfo.systemUptime - refreshWindow.interval
+
+        let refreshAttemptsWithinWindow = mutableState.refreshTimestamps.reduce(into: 0) { attempts, refreshTimestamp in
+            guard refreshWindowMin <= refreshTimestamp else { return }
+            attempts += 1
+        }
+
+        let isRefreshExcessive = refreshAttemptsWithinWindow >= refreshWindow.maximumAttempts
+
+        return isRefreshExcessive
+    }
+
+    private func handleRefreshSuccess(_ credential: Credential, insideLock mutableState: inout MutableState) {
+        mutableState.credential = credential
+
+        let adaptOperations = mutableState.adaptOperations
+        let requestsToRetry = mutableState.requestsToRetry
+
+        mutableState.adaptOperations.removeAll()
+        mutableState.requestsToRetry.removeAll()
+
+        mutableState.isRefreshing = false
+
+        // Dispatch to queue to hop out of the mutable state lock
+        queue.async {
+            adaptOperations.forEach { self.adapt($0.urlRequest, for: $0.session, completion: $0.completion) }
+            requestsToRetry.forEach { $0(.retry) }
+        }
+    }
+
+    private func handleRefreshFailure(_ error: Error, insideLock mutableState: inout MutableState) {
+        let adaptOperations = mutableState.adaptOperations
+        let requestsToRetry = mutableState.requestsToRetry
+
+        mutableState.adaptOperations.removeAll()
+        mutableState.requestsToRetry.removeAll()
+
+        mutableState.isRefreshing = false
+
+        // Dispatch to queue to hop out of the mutable state lock
+        queue.async {
+            adaptOperations.forEach { $0.completion(.failure(error)) }
+            requestsToRetry.forEach { $0(.doNotRetryWithError(error)) }
+        }
+    }
+}

Pods/Alamofire/Source/CachedResponseHandler.swift

@@ -0,0 +1,91 @@
+//
+//  CachedResponseHandler.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A type that handles whether the data task should store the HTTP response in the cache.
+public protocol CachedResponseHandler {
+    /// Determines whether the HTTP response should be stored in the cache.
+    ///
+    /// The `completion` closure should be passed one of three possible options:
+    ///
+    ///   1. The cached response provided by the server (this is the most common use case).
+    ///   2. A modified version of the cached response (you may want to modify it in some way before caching).
+    ///   3. A `nil` value to prevent the cached response from being stored in the cache.
+    ///
+    /// - Parameters:
+    ///   - task:       The data task whose request resulted in the cached response.
+    ///   - response:   The cached response to potentially store in the cache.
+    ///   - completion: The closure to execute containing cached response, a modified response, or `nil`.
+    func dataTask(_ task: URLSessionDataTask,
+                  willCacheResponse response: CachedURLResponse,
+                  completion: @escaping (CachedURLResponse?) -> Void)
+}
+
+// MARK: -
+
+/// `ResponseCacher` is a convenience `CachedResponseHandler` making it easy to cache, not cache, or modify a cached
+/// response.
+public struct ResponseCacher {
+    /// Defines the behavior of the `ResponseCacher` type.
+    public enum Behavior {
+        /// Stores the cached response in the cache.
+        case cache
+        /// Prevents the cached response from being stored in the cache.
+        case doNotCache
+        /// Modifies the cached response before storing it in the cache.
+        case modify((URLSessionDataTask, CachedURLResponse) -> CachedURLResponse?)
+    }
+
+    /// Returns a `ResponseCacher` with a `.cache` `Behavior`.
+    public static let cache = ResponseCacher(behavior: .cache)
+    /// Returns a `ResponseCacher` with a `.doNotCache` `Behavior`.
+    public static let doNotCache = ResponseCacher(behavior: .doNotCache)
+
+    /// The `Behavior` of the `ResponseCacher`.
+    public let behavior: Behavior
+
+    /// Creates a `ResponseCacher` instance from the `Behavior`.
+    ///
+    /// - Parameter behavior: The `Behavior`.
+    public init(behavior: Behavior) {
+        self.behavior = behavior
+    }
+}
+
+extension ResponseCacher: CachedResponseHandler {
+    public func dataTask(_ task: URLSessionDataTask,
+                         willCacheResponse response: CachedURLResponse,
+                         completion: @escaping (CachedURLResponse?) -> Void) {
+        switch behavior {
+        case .cache:
+            completion(response)
+        case .doNotCache:
+            completion(nil)
+        case let .modify(closure):
+            let response = closure(task, response)
+            completion(response)
+        }
+    }
+}

Pods/Alamofire/Source/Combine.swift

@@ -0,0 +1,622 @@
+//
+//  Combine.swift
+//
+//  Copyright (c) 2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+#if !((os(iOS) && (arch(i386) || arch(arm))) || os(Windows) || os(Linux))
+
+import Combine
+import Dispatch
+import Foundation
+
+// MARK: - DataRequest / UploadRequest
+
+/// A Combine `Publisher` that publishes the `DataResponse<Value, AFError>` of the provided `DataRequest`.
+@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+public struct DataResponsePublisher<Value>: Publisher {
+    public typealias Output = DataResponse<Value, AFError>
+    public typealias Failure = Never
+
+    private typealias Handler = (@escaping (_ response: DataResponse<Value, AFError>) -> Void) -> DataRequest
+
+    private let request: DataRequest
+    private let responseHandler: Handler
+
+    /// Creates an instance which will serialize responses using the provided `ResponseSerializer`.
+    ///
+    /// - Parameters:
+    ///   - request:    `DataRequest` for which to publish the response.
+    ///   - queue:      `DispatchQueue` on which the `DataResponse` value will be published. `.main` by default.
+    ///   - serializer: `ResponseSerializer` used to produce the published `DataResponse`.
+    public init<Serializer: ResponseSerializer>(_ request: DataRequest, queue: DispatchQueue, serializer: Serializer)
+        where Value == Serializer.SerializedObject {
+        self.request = request
+        responseHandler = { request.response(queue: queue, responseSerializer: serializer, completionHandler: $0) }
+    }
+
+    /// Creates an instance which will serialize responses using the provided `DataResponseSerializerProtocol`.
+    ///
+    /// - Parameters:
+    ///   - request:    `DataRequest` for which to publish the response.
+    ///   - queue:      `DispatchQueue` on which the `DataResponse` value will be published. `.main` by default.
+    ///   - serializer: `DataResponseSerializerProtocol` used to produce the published `DataResponse`.
+    public init<Serializer: DataResponseSerializerProtocol>(_ request: DataRequest,
+                                                            queue: DispatchQueue,
+                                                            serializer: Serializer)
+        where Value == Serializer.SerializedObject {
+        self.request = request
+        responseHandler = { request.response(queue: queue, responseSerializer: serializer, completionHandler: $0) }
+    }
+
+    /// Publishes only the `Result` of the `DataResponse` value.
+    ///
+    /// - Returns: The `AnyPublisher` publishing the `Result<Value, AFError>` value.
+    public func result() -> AnyPublisher<Result<Value, AFError>, Never> {
+        map { $0.result }.eraseToAnyPublisher()
+    }
+
+    /// Publishes the `Result` of the `DataResponse` as a single `Value` or fail with the `AFError` instance.
+    ///
+    /// - Returns: The `AnyPublisher<Value, AFError>` publishing the stream.
+    public func value() -> AnyPublisher<Value, AFError> {
+        setFailureType(to: AFError.self).flatMap { $0.result.publisher }.eraseToAnyPublisher()
+    }
+
+    public func receive<S>(subscriber: S) where S: Subscriber, DataResponsePublisher.Failure == S.Failure, DataResponsePublisher.Output == S.Input {
+        subscriber.receive(subscription: Inner(request: request,
+                                               responseHandler: responseHandler,
+                                               downstream: subscriber))
+    }
+
+    private final class Inner<Downstream: Subscriber>: Subscription, Cancellable
+        where Downstream.Input == Output {
+        typealias Failure = Downstream.Failure
+
+        @Protected
+        private var downstream: Downstream?
+        private let request: DataRequest
+        private let responseHandler: Handler
+
+        init(request: DataRequest, responseHandler: @escaping Handler, downstream: Downstream) {
+            self.request = request
+            self.responseHandler = responseHandler
+            self.downstream = downstream
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            assert(demand > 0)
+
+            guard let downstream = downstream else { return }
+
+            self.downstream = nil
+            responseHandler { response in
+                _ = downstream.receive(response)
+                downstream.receive(completion: .finished)
+            }.resume()
+        }
+
+        func cancel() {
+            request.cancel()
+            downstream = nil
+        }
+    }
+}
+
+@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+extension DataResponsePublisher where Value == Data? {
+    /// Creates an instance which publishes a `DataResponse<Data?, AFError>` value without serialization.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public init(_ request: DataRequest, queue: DispatchQueue) {
+        self.request = request
+        responseHandler = { request.response(queue: queue, completionHandler: $0) }
+    }
+}
+
+extension DataRequest {
+    /// Creates a `DataResponsePublisher` for this instance using the given `ResponseSerializer` and `DispatchQueue`.
+    ///
+    /// - Parameters:
+    ///   - serializer: `ResponseSerializer` used to serialize response `Data`.
+    ///   - queue:      `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///
+    /// - Returns:      The `DataResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishResponse<Serializer: ResponseSerializer, T>(using serializer: Serializer, on queue: DispatchQueue = .main) -> DataResponsePublisher<T>
+        where Serializer.SerializedObject == T {
+        DataResponsePublisher(self, queue: queue, serializer: serializer)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance and uses a `DataResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - queue:               `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    /// - Returns:               The `DataResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishData(queue: DispatchQueue = .main,
+                            preprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
+                            emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
+                            emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) -> DataResponsePublisher<Data> {
+        publishResponse(using: DataResponseSerializer(dataPreprocessor: preprocessor,
+                                                      emptyResponseCodes: emptyResponseCodes,
+                                                      emptyRequestMethods: emptyRequestMethods),
+                        on: queue)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance and uses a `StringResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - queue:               `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - encoding:            `String.Encoding` to parse the response. `nil` by default, in which case the encoding
+    ///                          will be determined by the server response, falling back to the default HTTP character
+    ///                          set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    ///
+    /// - Returns:               The `DataResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishString(queue: DispatchQueue = .main,
+                              preprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
+                              encoding: String.Encoding? = nil,
+                              emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
+                              emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods) -> DataResponsePublisher<String> {
+        publishResponse(using: StringResponseSerializer(dataPreprocessor: preprocessor,
+                                                        encoding: encoding,
+                                                        emptyResponseCodes: emptyResponseCodes,
+                                                        emptyRequestMethods: emptyRequestMethods),
+                        on: queue)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance and uses a `DecodableResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - type:                `Decodable` type to which to decode response `Data`. Inferred from the context by default.
+    ///   - queue:               `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - decoder:             `DataDecoder` instance used to decode response `Data`. `JSONDecoder()` by default.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    ///
+    /// - Returns:               The `DataResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishDecodable<T: Decodable>(type: T.Type = T.self,
+                                               queue: DispatchQueue = .main,
+                                               preprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
+                                               decoder: DataDecoder = JSONDecoder(),
+                                               emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
+                                               emptyResponseMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods) -> DataResponsePublisher<T> {
+        publishResponse(using: DecodableResponseSerializer(dataPreprocessor: preprocessor,
+                                                           decoder: decoder,
+                                                           emptyResponseCodes: emptyResponseCodes,
+                                                           emptyRequestMethods: emptyResponseMethods),
+                        on: queue)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance which does not serialize the response before publishing.
+    ///
+    ///   - queue: `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///
+    /// - Returns: The `DataResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishUnserialized(queue: DispatchQueue = .main) -> DataResponsePublisher<Data?> {
+        DataResponsePublisher(self, queue: queue)
+    }
+}
+
+// A Combine `Publisher` that publishes a sequence of `Stream<Value, AFError>` values received by the provided `DataStreamRequest`.
+@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+public struct DataStreamPublisher<Value>: Publisher {
+    public typealias Output = DataStreamRequest.Stream<Value, AFError>
+    public typealias Failure = Never
+
+    private typealias Handler = (@escaping DataStreamRequest.Handler<Value, AFError>) -> DataStreamRequest
+
+    private let request: DataStreamRequest
+    private let streamHandler: Handler
+
+    /// Creates an instance which will serialize responses using the provided `DataStreamSerializer`.
+    ///
+    /// - Parameters:
+    ///   - request:    `DataStreamRequest` for which to publish the response.
+    ///   - queue:      `DispatchQueue` on which the `Stream<Value, AFError>` values will be published. `.main` by
+    ///                 default.
+    ///   - serializer: `DataStreamSerializer` used to produce the published `Stream<Value, AFError>` values.
+    public init<Serializer: DataStreamSerializer>(_ request: DataStreamRequest, queue: DispatchQueue, serializer: Serializer)
+        where Value == Serializer.SerializedObject {
+        self.request = request
+        streamHandler = { request.responseStream(using: serializer, on: queue, stream: $0) }
+    }
+
+    /// Publishes only the `Result` of the `DataStreamRequest.Stream`'s `Event`s.
+    ///
+    /// - Returns: The `AnyPublisher` publishing the `Result<Value, AFError>` value.
+    public func result() -> AnyPublisher<Result<Value, AFError>, Never> {
+        compactMap { stream in
+            switch stream.event {
+            case let .stream(result):
+                return result
+            // If the stream has completed with an error, send the error value downstream as a `.failure`.
+            case let .complete(completion):
+                return completion.error.map(Result.failure)
+            }
+        }
+        .eraseToAnyPublisher()
+    }
+
+    /// Publishes the streamed values of the `DataStreamRequest.Stream` as a sequence of `Value` or fail with the
+    /// `AFError` instance.
+    ///
+    /// - Returns: The `AnyPublisher<Value, AFError>` publishing the stream.
+    public func value() -> AnyPublisher<Value, AFError> {
+        result().setFailureType(to: AFError.self).flatMap { $0.publisher }.eraseToAnyPublisher()
+    }
+
+    public func receive<S>(subscriber: S) where S: Subscriber, DataStreamPublisher.Failure == S.Failure, DataStreamPublisher.Output == S.Input {
+        subscriber.receive(subscription: Inner(request: request,
+                                               streamHandler: streamHandler,
+                                               downstream: subscriber))
+    }
+
+    private final class Inner<Downstream: Subscriber>: Subscription, Cancellable
+        where Downstream.Input == Output {
+        typealias Failure = Downstream.Failure
+
+        @Protected
+        private var downstream: Downstream?
+        private let request: DataStreamRequest
+        private let streamHandler: Handler
+
+        init(request: DataStreamRequest, streamHandler: @escaping Handler, downstream: Downstream) {
+            self.request = request
+            self.streamHandler = streamHandler
+            self.downstream = downstream
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            assert(demand > 0)
+
+            guard let downstream = downstream else { return }
+
+            self.downstream = nil
+            streamHandler { stream in
+                _ = downstream.receive(stream)
+                if case .complete = stream.event {
+                    downstream.receive(completion: .finished)
+                }
+            }.resume()
+        }
+
+        func cancel() {
+            request.cancel()
+            downstream = nil
+        }
+    }
+}
+
+extension DataStreamRequest {
+    /// Creates a `DataStreamPublisher` for this instance using the given `DataStreamSerializer` and `DispatchQueue`.
+    ///
+    /// - Parameters:
+    ///   - serializer: `DataStreamSerializer` used to serialize the streamed `Data`.
+    ///   - queue:      `DispatchQueue` on which the `DataRequest.Stream` values will be published. `.main` by default.
+    /// - Returns:      The `DataStreamPublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishStream<Serializer: DataStreamSerializer>(using serializer: Serializer,
+                                                                on queue: DispatchQueue = .main) -> DataStreamPublisher<Serializer.SerializedObject> {
+        DataStreamPublisher(self, queue: queue, serializer: serializer)
+    }
+
+    /// Creates a `DataStreamPublisher` for this instance which uses a `PassthroughStreamSerializer` to stream `Data`
+    /// unserialized.
+    ///
+    /// - Parameters:
+    ///   - queue:      `DispatchQueue` on which the `DataRequest.Stream` values will be published. `.main` by default.
+    /// - Returns:      The `DataStreamPublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishData(queue: DispatchQueue = .main) -> DataStreamPublisher<Data> {
+        publishStream(using: PassthroughStreamSerializer(), on: queue)
+    }
+
+    /// Creates a `DataStreamPublisher` for this instance which uses a `StringStreamSerializer` to serialize stream
+    /// `Data` values into `String` values.
+    ///
+    /// - Parameters:
+    ///   - queue:      `DispatchQueue` on which the `DataRequest.Stream` values will be published. `.main` by default.
+    /// - Returns:      The `DataStreamPublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishString(queue: DispatchQueue = .main) -> DataStreamPublisher<String> {
+        publishStream(using: StringStreamSerializer(), on: queue)
+    }
+
+    /// Creates a `DataStreamPublisher` for this instance which uses a `DecodableStreamSerializer` with the provided
+    /// parameters to serialize stream `Data` values into the provided type.
+    ///
+    /// - Parameters:
+    ///   - type:         `Decodable` type to which to decode stream `Data`. Inferred from the context by default.
+    ///   - queue:        `DispatchQueue` on which the `DataRequest.Stream` values will be published. `.main` by default.
+    ///   - decoder:      `DataDecoder` instance used to decode stream `Data`. `JSONDecoder()` by default.
+    ///   - preprocessor: `DataPreprocessor` which filters incoming stream `Data` before serialization.
+    ///                   `PassthroughPreprocessor()` by default.
+    /// - Returns:        The `DataStreamPublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishDecodable<T: Decodable>(type: T.Type = T.self,
+                                               queue: DispatchQueue = .main,
+                                               decoder: DataDecoder = JSONDecoder(),
+                                               preprocessor: DataPreprocessor = PassthroughPreprocessor()) -> DataStreamPublisher<T> {
+        publishStream(using: DecodableStreamSerializer(decoder: decoder,
+                                                       dataPreprocessor: preprocessor),
+                      on: queue)
+    }
+}
+
+/// A Combine `Publisher` that publishes the `DownloadResponse<Value, AFError>` of the provided `DownloadRequest`.
+@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+public struct DownloadResponsePublisher<Value>: Publisher {
+    public typealias Output = DownloadResponse<Value, AFError>
+    public typealias Failure = Never
+
+    private typealias Handler = (@escaping (_ response: DownloadResponse<Value, AFError>) -> Void) -> DownloadRequest
+
+    private let request: DownloadRequest
+    private let responseHandler: Handler
+
+    /// Creates an instance which will serialize responses using the provided `ResponseSerializer`.
+    ///
+    /// - Parameters:
+    ///   - request:    `DownloadRequest` for which to publish the response.
+    ///   - queue:      `DispatchQueue` on which the `DownloadResponse` value will be published. `.main` by default.
+    ///   - serializer: `ResponseSerializer` used to produce the published `DownloadResponse`.
+    public init<Serializer: ResponseSerializer>(_ request: DownloadRequest, queue: DispatchQueue, serializer: Serializer)
+        where Value == Serializer.SerializedObject {
+        self.request = request
+        responseHandler = { request.response(queue: queue, responseSerializer: serializer, completionHandler: $0) }
+    }
+
+    /// Creates an instance which will serialize responses using the provided `DownloadResponseSerializerProtocol` value.
+    ///
+    /// - Parameters:
+    ///   - request:    `DownloadRequest` for which to publish the response.
+    ///   - queue:      `DispatchQueue` on which the `DataResponse` value will be published. `.main` by default.
+    ///   - serializer: `DownloadResponseSerializerProtocol` used to produce the published `DownloadResponse`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public init<Serializer: DownloadResponseSerializerProtocol>(_ request: DownloadRequest,
+                                                                queue: DispatchQueue,
+                                                                serializer: Serializer)
+        where Value == Serializer.SerializedObject {
+        self.request = request
+        responseHandler = { request.response(queue: queue, responseSerializer: serializer, completionHandler: $0) }
+    }
+
+    /// Publishes only the `Result` of the `DownloadResponse` value.
+    ///
+    /// - Returns: The `AnyPublisher` publishing the `Result<Value, AFError>` value.
+    public func result() -> AnyPublisher<Result<Value, AFError>, Never> {
+        map { $0.result }.eraseToAnyPublisher()
+    }
+
+    /// Publishes the `Result` of the `DownloadResponse` as a single `Value` or fail with the `AFError` instance.
+    ///
+    /// - Returns: The `AnyPublisher<Value, AFError>` publishing the stream.
+    public func value() -> AnyPublisher<Value, AFError> {
+        setFailureType(to: AFError.self).flatMap { $0.result.publisher }.eraseToAnyPublisher()
+    }
+
+    public func receive<S>(subscriber: S) where S: Subscriber, DownloadResponsePublisher.Failure == S.Failure, DownloadResponsePublisher.Output == S.Input {
+        subscriber.receive(subscription: Inner(request: request,
+                                               responseHandler: responseHandler,
+                                               downstream: subscriber))
+    }
+
+    private final class Inner<Downstream: Subscriber>: Subscription, Cancellable
+        where Downstream.Input == Output {
+        typealias Failure = Downstream.Failure
+
+        @Protected
+        private var downstream: Downstream?
+        private let request: DownloadRequest
+        private let responseHandler: Handler
+
+        init(request: DownloadRequest, responseHandler: @escaping Handler, downstream: Downstream) {
+            self.request = request
+            self.responseHandler = responseHandler
+            self.downstream = downstream
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            assert(demand > 0)
+
+            guard let downstream = downstream else { return }
+
+            self.downstream = nil
+            responseHandler { response in
+                _ = downstream.receive(response)
+                downstream.receive(completion: .finished)
+            }.resume()
+        }
+
+        func cancel() {
+            request.cancel()
+            downstream = nil
+        }
+    }
+}
+
+extension DownloadRequest {
+    /// Creates a `DownloadResponsePublisher` for this instance using the given `ResponseSerializer` and `DispatchQueue`.
+    ///
+    /// - Parameters:
+    ///   - serializer: `ResponseSerializer` used to serialize the response `Data` from disk.
+    ///   - queue:      `DispatchQueue` on which the `DownloadResponse` will be published.`.main` by default.
+    ///
+    /// - Returns:      The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishResponse<Serializer: ResponseSerializer, T>(using serializer: Serializer, on queue: DispatchQueue = .main) -> DownloadResponsePublisher<T>
+        where Serializer.SerializedObject == T {
+        DownloadResponsePublisher(self, queue: queue, serializer: serializer)
+    }
+
+    /// Creates a `DownloadResponsePublisher` for this instance using the given `DownloadResponseSerializerProtocol` and
+    /// `DispatchQueue`.
+    ///
+    /// - Parameters:
+    ///   - serializer: `DownloadResponseSerializer` used to serialize the response `Data` from disk.
+    ///   - queue:      `DispatchQueue` on which the `DownloadResponse` will be published.`.main` by default.
+    ///
+    /// - Returns:      The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishResponse<Serializer: DownloadResponseSerializerProtocol, T>(using serializer: Serializer, on queue: DispatchQueue = .main) -> DownloadResponsePublisher<T>
+        where Serializer.SerializedObject == T {
+        DownloadResponsePublisher(self, queue: queue, serializer: serializer)
+    }
+
+    /// Creates a `DownloadResponsePublisher` for this instance and uses a `URLResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameter queue: `DispatchQueue` on which the `DownloadResponse` will be published. `.main` by default.
+    ///
+    /// - Returns:         The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishURL(queue: DispatchQueue = .main) -> DownloadResponsePublisher<URL> {
+        publishResponse(using: URLResponseSerializer(), on: queue)
+    }
+
+    /// Creates a `DownloadResponsePublisher` for this instance and uses a `DataResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - queue:               `DispatchQueue` on which the `DownloadResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    ///
+    /// - Returns:               The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishData(queue: DispatchQueue = .main,
+                            preprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
+                            emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
+                            emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) -> DownloadResponsePublisher<Data> {
+        publishResponse(using: DataResponseSerializer(dataPreprocessor: preprocessor,
+                                                      emptyResponseCodes: emptyResponseCodes,
+                                                      emptyRequestMethods: emptyRequestMethods),
+                        on: queue)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance and uses a `StringResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - queue:               `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - encoding:            `String.Encoding` to parse the response. `nil` by default, in which case the encoding
+    ///                          will be determined by the server response, falling back to the default HTTP character
+    ///                          set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    ///
+    /// - Returns:               The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishString(queue: DispatchQueue = .main,
+                              preprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
+                              encoding: String.Encoding? = nil,
+                              emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
+                              emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods) -> DownloadResponsePublisher<String> {
+        publishResponse(using: StringResponseSerializer(dataPreprocessor: preprocessor,
+                                                        encoding: encoding,
+                                                        emptyResponseCodes: emptyResponseCodes,
+                                                        emptyRequestMethods: emptyRequestMethods),
+                        on: queue)
+    }
+
+    /// Creates a `DataResponsePublisher` for this instance and uses a `DecodableResponseSerializer` to serialize the
+    /// response.
+    ///
+    /// - Parameters:
+    ///   - type:                `Decodable` type to which to decode response `Data`. Inferred from the context by default.
+    ///   - queue:               `DispatchQueue` on which the `DataResponse` will be published. `.main` by default.
+    ///   - preprocessor:        `DataPreprocessor` which filters the `Data` before serialization. `PassthroughPreprocessor()`
+    ///                          by default.
+    ///   - decoder:             `DataDecoder` instance used to decode response `Data`. `JSONDecoder()` by default.
+    ///   - emptyResponseCodes:  `Set<Int>` of HTTP status codes for which empty responses are allowed. `[204, 205]` by
+    ///                          default.
+    ///   - emptyRequestMethods: `Set<HTTPMethod>` of `HTTPMethod`s for which empty responses are allowed, regardless of
+    ///                          status code. `[.head]` by default.
+    ///
+    /// - Returns:               The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishDecodable<T: Decodable>(type: T.Type = T.self,
+                                               queue: DispatchQueue = .main,
+                                               preprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
+                                               decoder: DataDecoder = JSONDecoder(),
+                                               emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
+                                               emptyResponseMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods) -> DownloadResponsePublisher<T> {
+        publishResponse(using: DecodableResponseSerializer(dataPreprocessor: preprocessor,
+                                                           decoder: decoder,
+                                                           emptyResponseCodes: emptyResponseCodes,
+                                                           emptyRequestMethods: emptyResponseMethods),
+                        on: queue)
+    }
+}
+
+@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+extension DownloadResponsePublisher where Value == URL? {
+    /// Creates an instance which publishes a `DownloadResponse<URL?, AFError>` value without serialization.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public init(_ request: DownloadRequest, queue: DispatchQueue) {
+        self.request = request
+        responseHandler = { request.response(queue: queue, completionHandler: $0) }
+    }
+}
+
+extension DownloadRequest {
+    /// Creates a `DownloadResponsePublisher` for this instance which does not serialize the response before publishing.
+    ///
+    /// - Parameter queue: `DispatchQueue` on which the `DownloadResponse` will be published. `.main` by default.
+    ///
+    /// - Returns:         The `DownloadResponsePublisher`.
+    @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+    public func publishUnserialized(on queue: DispatchQueue = .main) -> DownloadResponsePublisher<URL?> {
+        DownloadResponsePublisher(self, queue: queue)
+    }
+}
+
+#endif

Pods/Alamofire/Source/DispatchQueue+Alamofire.swift

@@ -0,0 +1,37 @@
+//
+//  DispatchQueue+Alamofire.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Dispatch
+import Foundation
+
+extension DispatchQueue {
+    /// Execute the provided closure after a `TimeInterval`.
+    ///
+    /// - Parameters:
+    ///   - delay:   `TimeInterval` to delay execution.
+    ///   - closure: Closure to execute.
+    func after(_ delay: TimeInterval, execute closure: @escaping () -> Void) {
+        asyncAfter(deadline: .now() + delay, execute: closure)
+    }
+}

Pods/Alamofire/Source/EventMonitor.swift

@@ -0,0 +1,892 @@
+//
+//  EventMonitor.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Protocol outlining the lifetime events inside Alamofire. It includes both events received from the various
+/// `URLSession` delegate protocols as well as various events from the lifetime of `Request` and its subclasses.
+public protocol EventMonitor {
+    /// The `DispatchQueue` onto which Alamofire's root `CompositeEventMonitor` will dispatch events. `.main` by default.
+    var queue: DispatchQueue { get }
+
+    // MARK: - URLSession Events
+
+    // MARK: URLSessionDelegate Events
+
+    /// Event called during `URLSessionDelegate`'s `urlSession(_:didBecomeInvalidWithError:)` method.
+    func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?)
+
+    // MARK: URLSessionTaskDelegate Events
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:didReceive:completionHandler:)` method.
+    func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:didSendBodyData:totalBytesSent:totalBytesExpectedToSend:)` method.
+    func urlSession(_ session: URLSession,
+                    task: URLSessionTask,
+                    didSendBodyData bytesSent: Int64,
+                    totalBytesSent: Int64,
+                    totalBytesExpectedToSend: Int64)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:needNewBodyStream:)` method.
+    func urlSession(_ session: URLSession, taskNeedsNewBodyStream task: URLSessionTask)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:willPerformHTTPRedirection:newRequest:completionHandler:)` method.
+    func urlSession(_ session: URLSession,
+                    task: URLSessionTask,
+                    willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:didFinishCollecting:)` method.
+    func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:task:didCompleteWithError:)` method.
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?)
+
+    /// Event called during `URLSessionTaskDelegate`'s `urlSession(_:taskIsWaitingForConnectivity:)` method.
+    @available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)
+    func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask)
+
+    // MARK: URLSessionDataDelegate Events
+
+    /// Event called during `URLSessionDataDelegate`'s `urlSession(_:dataTask:didReceive:)` method.
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data)
+
+    /// Event called during `URLSessionDataDelegate`'s `urlSession(_:dataTask:willCacheResponse:completionHandler:)` method.
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, willCacheResponse proposedResponse: CachedURLResponse)
+
+    // MARK: URLSessionDownloadDelegate Events
+
+    /// Event called during `URLSessionDownloadDelegate`'s `urlSession(_:downloadTask:didResumeAtOffset:expectedTotalBytes:)` method.
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didResumeAtOffset fileOffset: Int64,
+                    expectedTotalBytes: Int64)
+
+    /// Event called during `URLSessionDownloadDelegate`'s `urlSession(_:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:)` method.
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didWriteData bytesWritten: Int64,
+                    totalBytesWritten: Int64,
+                    totalBytesExpectedToWrite: Int64)
+
+    /// Event called during `URLSessionDownloadDelegate`'s `urlSession(_:downloadTask:didFinishDownloadingTo:)` method.
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL)
+
+    // MARK: - Request Events
+
+    /// Event called when a `URLRequest` is first created for a `Request`. If a `RequestAdapter` is active, the
+    /// `URLRequest` will be adapted before being issued.
+    func request(_ request: Request, didCreateInitialURLRequest urlRequest: URLRequest)
+
+    /// Event called when the attempt to create a `URLRequest` from a `Request`'s original `URLRequestConvertible` value fails.
+    func request(_ request: Request, didFailToCreateURLRequestWithError error: AFError)
+
+    /// Event called when a `RequestAdapter` adapts the `Request`'s initial `URLRequest`.
+    func request(_ request: Request, didAdaptInitialRequest initialRequest: URLRequest, to adaptedRequest: URLRequest)
+
+    /// Event called when a `RequestAdapter` fails to adapt the `Request`'s initial `URLRequest`.
+    func request(_ request: Request, didFailToAdaptURLRequest initialRequest: URLRequest, withError error: AFError)
+
+    /// Event called when a final `URLRequest` is created for a `Request`.
+    func request(_ request: Request, didCreateURLRequest urlRequest: URLRequest)
+
+    /// Event called when a `URLSessionTask` subclass instance is created for a `Request`.
+    func request(_ request: Request, didCreateTask task: URLSessionTask)
+
+    /// Event called when a `Request` receives a `URLSessionTaskMetrics` value.
+    func request(_ request: Request, didGatherMetrics metrics: URLSessionTaskMetrics)
+
+    /// Event called when a `Request` fails due to an error created by Alamofire. e.g. When certificate pinning fails.
+    func request(_ request: Request, didFailTask task: URLSessionTask, earlyWithError error: AFError)
+
+    /// Event called when a `Request`'s task completes, possibly with an error. A `Request` may receive this event
+    /// multiple times if it is retried.
+    func request(_ request: Request, didCompleteTask task: URLSessionTask, with error: AFError?)
+
+    /// Event called when a `Request` is about to be retried.
+    func requestIsRetrying(_ request: Request)
+
+    /// Event called when a `Request` finishes and response serializers are being called.
+    func requestDidFinish(_ request: Request)
+
+    /// Event called when a `Request` receives a `resume` call.
+    func requestDidResume(_ request: Request)
+
+    /// Event called when a `Request`'s associated `URLSessionTask` is resumed.
+    func request(_ request: Request, didResumeTask task: URLSessionTask)
+
+    /// Event called when a `Request` receives a `suspend` call.
+    func requestDidSuspend(_ request: Request)
+
+    /// Event called when a `Request`'s associated `URLSessionTask` is suspended.
+    func request(_ request: Request, didSuspendTask task: URLSessionTask)
+
+    /// Event called when a `Request` receives a `cancel` call.
+    func requestDidCancel(_ request: Request)
+
+    /// Event called when a `Request`'s associated `URLSessionTask` is cancelled.
+    func request(_ request: Request, didCancelTask task: URLSessionTask)
+
+    // MARK: DataRequest Events
+
+    /// Event called when a `DataRequest` calls a `Validation`.
+    func request(_ request: DataRequest,
+                 didValidateRequest urlRequest: URLRequest?,
+                 response: HTTPURLResponse,
+                 data: Data?,
+                 withResult result: Request.ValidationResult)
+
+    /// Event called when a `DataRequest` creates a `DataResponse<Data?>` value without calling a `ResponseSerializer`.
+    func request(_ request: DataRequest, didParseResponse response: DataResponse<Data?, AFError>)
+
+    /// Event called when a `DataRequest` calls a `ResponseSerializer` and creates a generic `DataResponse<Value, AFError>`.
+    func request<Value>(_ request: DataRequest, didParseResponse response: DataResponse<Value, AFError>)
+
+    // MARK: DataStreamRequest Events
+
+    /// Event called when a `DataStreamRequest` calls a `Validation` closure.
+    ///
+    /// - Parameters:
+    ///   - request:    `DataStreamRequest` which is calling the `Validation`.
+    ///   - urlRequest: `URLRequest` of the request being validated.
+    ///   - response:   `HTTPURLResponse` of the request being validated.
+    ///   - result:      Produced `ValidationResult`.
+    func request(_ request: DataStreamRequest,
+                 didValidateRequest urlRequest: URLRequest?,
+                 response: HTTPURLResponse,
+                 withResult result: Request.ValidationResult)
+
+    /// Event called when a `DataStreamSerializer` produces a value from streamed `Data`.
+    ///
+    /// - Parameters:
+    ///   - request: `DataStreamRequest` for which the value was serialized.
+    ///   - result:  `Result` of the serialization attempt.
+    func request<Value>(_ request: DataStreamRequest, didParseStream result: Result<Value, AFError>)
+
+    // MARK: UploadRequest Events
+
+    /// Event called when an `UploadRequest` creates its `Uploadable` value, indicating the type of upload it represents.
+    func request(_ request: UploadRequest, didCreateUploadable uploadable: UploadRequest.Uploadable)
+
+    /// Event called when an `UploadRequest` failed to create its `Uploadable` value due to an error.
+    func request(_ request: UploadRequest, didFailToCreateUploadableWithError error: AFError)
+
+    /// Event called when an `UploadRequest` provides the `InputStream` from its `Uploadable` value. This only occurs if
+    /// the `InputStream` does not wrap a `Data` value or file `URL`.
+    func request(_ request: UploadRequest, didProvideInputStream stream: InputStream)
+
+    // MARK: DownloadRequest Events
+
+    /// Event called when a `DownloadRequest`'s `URLSessionDownloadTask` finishes and the temporary file has been moved.
+    func request(_ request: DownloadRequest, didFinishDownloadingUsing task: URLSessionTask, with result: Result<URL, AFError>)
+
+    /// Event called when a `DownloadRequest`'s `Destination` closure is called and creates the destination URL the
+    /// downloaded file will be moved to.
+    func request(_ request: DownloadRequest, didCreateDestinationURL url: URL)
+
+    /// Event called when a `DownloadRequest` calls a `Validation`.
+    func request(_ request: DownloadRequest,
+                 didValidateRequest urlRequest: URLRequest?,
+                 response: HTTPURLResponse,
+                 fileURL: URL?,
+                 withResult result: Request.ValidationResult)
+
+    /// Event called when a `DownloadRequest` creates a `DownloadResponse<URL?, AFError>` without calling a `ResponseSerializer`.
+    func request(_ request: DownloadRequest, didParseResponse response: DownloadResponse<URL?, AFError>)
+
+    /// Event called when a `DownloadRequest` calls a `DownloadResponseSerializer` and creates a generic `DownloadResponse<Value, AFError>`
+    func request<Value>(_ request: DownloadRequest, didParseResponse response: DownloadResponse<Value, AFError>)
+}
+
+extension EventMonitor {
+    /// The default queue on which `CompositeEventMonitor`s will call the `EventMonitor` methods. `.main` by default.
+    public var queue: DispatchQueue { .main }
+
+    // MARK: Default Implementations
+
+    public func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {}
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didReceive challenge: URLAuthenticationChallenge) {}
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didSendBodyData bytesSent: Int64,
+                           totalBytesSent: Int64,
+                           totalBytesExpectedToSend: Int64) {}
+    public func urlSession(_ session: URLSession, taskNeedsNewBodyStream task: URLSessionTask) {}
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest) {}
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didFinishCollecting metrics: URLSessionTaskMetrics) {}
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {}
+    public func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask) {}
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {}
+    public func urlSession(_ session: URLSession,
+                           dataTask: URLSessionDataTask,
+                           willCacheResponse proposedResponse: CachedURLResponse) {}
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didResumeAtOffset fileOffset: Int64,
+                           expectedTotalBytes: Int64) {}
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didWriteData bytesWritten: Int64,
+                           totalBytesWritten: Int64,
+                           totalBytesExpectedToWrite: Int64) {}
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didFinishDownloadingTo location: URL) {}
+    public func request(_ request: Request, didCreateInitialURLRequest urlRequest: URLRequest) {}
+    public func request(_ request: Request, didFailToCreateURLRequestWithError error: AFError) {}
+    public func request(_ request: Request,
+                        didAdaptInitialRequest initialRequest: URLRequest,
+                        to adaptedRequest: URLRequest) {}
+    public func request(_ request: Request,
+                        didFailToAdaptURLRequest initialRequest: URLRequest,
+                        withError error: AFError) {}
+    public func request(_ request: Request, didCreateURLRequest urlRequest: URLRequest) {}
+    public func request(_ request: Request, didCreateTask task: URLSessionTask) {}
+    public func request(_ request: Request, didGatherMetrics metrics: URLSessionTaskMetrics) {}
+    public func request(_ request: Request, didFailTask task: URLSessionTask, earlyWithError error: AFError) {}
+    public func request(_ request: Request, didCompleteTask task: URLSessionTask, with error: AFError?) {}
+    public func requestIsRetrying(_ request: Request) {}
+    public func requestDidFinish(_ request: Request) {}
+    public func requestDidResume(_ request: Request) {}
+    public func request(_ request: Request, didResumeTask task: URLSessionTask) {}
+    public func requestDidSuspend(_ request: Request) {}
+    public func request(_ request: Request, didSuspendTask task: URLSessionTask) {}
+    public func requestDidCancel(_ request: Request) {}
+    public func request(_ request: Request, didCancelTask task: URLSessionTask) {}
+    public func request(_ request: DataRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        data: Data?,
+                        withResult result: Request.ValidationResult) {}
+    public func request(_ request: DataRequest, didParseResponse response: DataResponse<Data?, AFError>) {}
+    public func request<Value>(_ request: DataRequest, didParseResponse response: DataResponse<Value, AFError>) {}
+    public func request(_ request: DataStreamRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        withResult result: Request.ValidationResult) {}
+    public func request<Value>(_ request: DataStreamRequest, didParseStream result: Result<Value, AFError>) {}
+    public func request(_ request: UploadRequest, didCreateUploadable uploadable: UploadRequest.Uploadable) {}
+    public func request(_ request: UploadRequest, didFailToCreateUploadableWithError error: AFError) {}
+    public func request(_ request: UploadRequest, didProvideInputStream stream: InputStream) {}
+    public func request(_ request: DownloadRequest, didFinishDownloadingUsing task: URLSessionTask, with result: Result<URL, AFError>) {}
+    public func request(_ request: DownloadRequest, didCreateDestinationURL url: URL) {}
+    public func request(_ request: DownloadRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        fileURL: URL?,
+                        withResult result: Request.ValidationResult) {}
+    public func request(_ request: DownloadRequest, didParseResponse response: DownloadResponse<URL?, AFError>) {}
+    public func request<Value>(_ request: DownloadRequest, didParseResponse response: DownloadResponse<Value, AFError>) {}
+}
+
+/// An `EventMonitor` which can contain multiple `EventMonitor`s and calls their methods on their queues.
+public final class CompositeEventMonitor: EventMonitor {
+    public let queue = DispatchQueue(label: "org.alamofire.compositeEventMonitor", qos: .utility)
+
+    let monitors: [EventMonitor]
+
+    init(monitors: [EventMonitor]) {
+        self.monitors = monitors
+    }
+
+    func performEvent(_ event: @escaping (EventMonitor) -> Void) {
+        queue.async {
+            for monitor in self.monitors {
+                monitor.queue.async { event(monitor) }
+            }
+        }
+    }
+
+    public func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {
+        performEvent { $0.urlSession(session, didBecomeInvalidWithError: error) }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didReceive challenge: URLAuthenticationChallenge) {
+        performEvent { $0.urlSession(session, task: task, didReceive: challenge) }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didSendBodyData bytesSent: Int64,
+                           totalBytesSent: Int64,
+                           totalBytesExpectedToSend: Int64) {
+        performEvent {
+            $0.urlSession(session,
+                          task: task,
+                          didSendBodyData: bytesSent,
+                          totalBytesSent: totalBytesSent,
+                          totalBytesExpectedToSend: totalBytesExpectedToSend)
+        }
+    }
+
+    public func urlSession(_ session: URLSession, taskNeedsNewBodyStream task: URLSessionTask) {
+        performEvent {
+            $0.urlSession(session, taskNeedsNewBodyStream: task)
+        }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest) {
+        performEvent {
+            $0.urlSession(session,
+                          task: task,
+                          willPerformHTTPRedirection: response,
+                          newRequest: request)
+        }
+    }
+
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
+        performEvent { $0.urlSession(session, task: task, didFinishCollecting: metrics) }
+    }
+
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        performEvent { $0.urlSession(session, task: task, didCompleteWithError: error) }
+    }
+
+    @available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)
+    public func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask) {
+        performEvent { $0.urlSession(session, taskIsWaitingForConnectivity: task) }
+    }
+
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        performEvent { $0.urlSession(session, dataTask: dataTask, didReceive: data) }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           dataTask: URLSessionDataTask,
+                           willCacheResponse proposedResponse: CachedURLResponse) {
+        performEvent { $0.urlSession(session, dataTask: dataTask, willCacheResponse: proposedResponse) }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didResumeAtOffset fileOffset: Int64,
+                           expectedTotalBytes: Int64) {
+        performEvent {
+            $0.urlSession(session,
+                          downloadTask: downloadTask,
+                          didResumeAtOffset: fileOffset,
+                          expectedTotalBytes: expectedTotalBytes)
+        }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didWriteData bytesWritten: Int64,
+                           totalBytesWritten: Int64,
+                           totalBytesExpectedToWrite: Int64) {
+        performEvent {
+            $0.urlSession(session,
+                          downloadTask: downloadTask,
+                          didWriteData: bytesWritten,
+                          totalBytesWritten: totalBytesWritten,
+                          totalBytesExpectedToWrite: totalBytesExpectedToWrite)
+        }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           downloadTask: URLSessionDownloadTask,
+                           didFinishDownloadingTo location: URL) {
+        performEvent { $0.urlSession(session, downloadTask: downloadTask, didFinishDownloadingTo: location) }
+    }
+
+    public func request(_ request: Request, didCreateInitialURLRequest urlRequest: URLRequest) {
+        performEvent { $0.request(request, didCreateInitialURLRequest: urlRequest) }
+    }
+
+    public func request(_ request: Request, didFailToCreateURLRequestWithError error: AFError) {
+        performEvent { $0.request(request, didFailToCreateURLRequestWithError: error) }
+    }
+
+    public func request(_ request: Request, didAdaptInitialRequest initialRequest: URLRequest, to adaptedRequest: URLRequest) {
+        performEvent { $0.request(request, didAdaptInitialRequest: initialRequest, to: adaptedRequest) }
+    }
+
+    public func request(_ request: Request, didFailToAdaptURLRequest initialRequest: URLRequest, withError error: AFError) {
+        performEvent { $0.request(request, didFailToAdaptURLRequest: initialRequest, withError: error) }
+    }
+
+    public func request(_ request: Request, didCreateURLRequest urlRequest: URLRequest) {
+        performEvent { $0.request(request, didCreateURLRequest: urlRequest) }
+    }
+
+    public func request(_ request: Request, didCreateTask task: URLSessionTask) {
+        performEvent { $0.request(request, didCreateTask: task) }
+    }
+
+    public func request(_ request: Request, didGatherMetrics metrics: URLSessionTaskMetrics) {
+        performEvent { $0.request(request, didGatherMetrics: metrics) }
+    }
+
+    public func request(_ request: Request, didFailTask task: URLSessionTask, earlyWithError error: AFError) {
+        performEvent { $0.request(request, didFailTask: task, earlyWithError: error) }
+    }
+
+    public func request(_ request: Request, didCompleteTask task: URLSessionTask, with error: AFError?) {
+        performEvent { $0.request(request, didCompleteTask: task, with: error) }
+    }
+
+    public func requestIsRetrying(_ request: Request) {
+        performEvent { $0.requestIsRetrying(request) }
+    }
+
+    public func requestDidFinish(_ request: Request) {
+        performEvent { $0.requestDidFinish(request) }
+    }
+
+    public func requestDidResume(_ request: Request) {
+        performEvent { $0.requestDidResume(request) }
+    }
+
+    public func request(_ request: Request, didResumeTask task: URLSessionTask) {
+        performEvent { $0.request(request, didResumeTask: task) }
+    }
+
+    public func requestDidSuspend(_ request: Request) {
+        performEvent { $0.requestDidSuspend(request) }
+    }
+
+    public func request(_ request: Request, didSuspendTask task: URLSessionTask) {
+        performEvent { $0.request(request, didSuspendTask: task) }
+    }
+
+    public func requestDidCancel(_ request: Request) {
+        performEvent { $0.requestDidCancel(request) }
+    }
+
+    public func request(_ request: Request, didCancelTask task: URLSessionTask) {
+        performEvent { $0.request(request, didCancelTask: task) }
+    }
+
+    public func request(_ request: DataRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        data: Data?,
+                        withResult result: Request.ValidationResult) {
+        performEvent { $0.request(request,
+                                  didValidateRequest: urlRequest,
+                                  response: response,
+                                  data: data,
+                                  withResult: result)
+        }
+    }
+
+    public func request(_ request: DataRequest, didParseResponse response: DataResponse<Data?, AFError>) {
+        performEvent { $0.request(request, didParseResponse: response) }
+    }
+
+    public func request<Value>(_ request: DataRequest, didParseResponse response: DataResponse<Value, AFError>) {
+        performEvent { $0.request(request, didParseResponse: response) }
+    }
+
+    public func request(_ request: DataStreamRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        withResult result: Request.ValidationResult) {
+        performEvent { $0.request(request,
+                                  didValidateRequest: urlRequest,
+                                  response: response,
+                                  withResult: result)
+        }
+    }
+
+    public func request<Value>(_ request: DataStreamRequest, didParseStream result: Result<Value, AFError>) {
+        performEvent { $0.request(request, didParseStream: result) }
+    }
+
+    public func request(_ request: UploadRequest, didCreateUploadable uploadable: UploadRequest.Uploadable) {
+        performEvent { $0.request(request, didCreateUploadable: uploadable) }
+    }
+
+    public func request(_ request: UploadRequest, didFailToCreateUploadableWithError error: AFError) {
+        performEvent { $0.request(request, didFailToCreateUploadableWithError: error) }
+    }
+
+    public func request(_ request: UploadRequest, didProvideInputStream stream: InputStream) {
+        performEvent { $0.request(request, didProvideInputStream: stream) }
+    }
+
+    public func request(_ request: DownloadRequest, didFinishDownloadingUsing task: URLSessionTask, with result: Result<URL, AFError>) {
+        performEvent { $0.request(request, didFinishDownloadingUsing: task, with: result) }
+    }
+
+    public func request(_ request: DownloadRequest, didCreateDestinationURL url: URL) {
+        performEvent { $0.request(request, didCreateDestinationURL: url) }
+    }
+
+    public func request(_ request: DownloadRequest,
+                        didValidateRequest urlRequest: URLRequest?,
+                        response: HTTPURLResponse,
+                        fileURL: URL?,
+                        withResult result: Request.ValidationResult) {
+        performEvent { $0.request(request,
+                                  didValidateRequest: urlRequest,
+                                  response: response,
+                                  fileURL: fileURL,
+                                  withResult: result) }
+    }
+
+    public func request(_ request: DownloadRequest, didParseResponse response: DownloadResponse<URL?, AFError>) {
+        performEvent { $0.request(request, didParseResponse: response) }
+    }
+
+    public func request<Value>(_ request: DownloadRequest, didParseResponse response: DownloadResponse<Value, AFError>) {
+        performEvent { $0.request(request, didParseResponse: response) }
+    }
+}
+
+/// `EventMonitor` that allows optional closures to be set to receive events.
+open class ClosureEventMonitor: EventMonitor {
+    /// Closure called on the `urlSession(_:didBecomeInvalidWithError:)` event.
+    open var sessionDidBecomeInvalidWithError: ((URLSession, Error?) -> Void)?
+
+    /// Closure called on the `urlSession(_:task:didReceive:completionHandler:)`.
+    open var taskDidReceiveChallenge: ((URLSession, URLSessionTask, URLAuthenticationChallenge) -> Void)?
+
+    /// Closure that receives `urlSession(_:task:didSendBodyData:totalBytesSent:totalBytesExpectedToSend:)` event.
+    open var taskDidSendBodyData: ((URLSession, URLSessionTask, Int64, Int64, Int64) -> Void)?
+
+    /// Closure called on the `urlSession(_:task:needNewBodyStream:)` event.
+    open var taskNeedNewBodyStream: ((URLSession, URLSessionTask) -> Void)?
+
+    /// Closure called on the `urlSession(_:task:willPerformHTTPRedirection:newRequest:completionHandler:)` event.
+    open var taskWillPerformHTTPRedirection: ((URLSession, URLSessionTask, HTTPURLResponse, URLRequest) -> Void)?
+
+    /// Closure called on the `urlSession(_:task:didFinishCollecting:)` event.
+    open var taskDidFinishCollectingMetrics: ((URLSession, URLSessionTask, URLSessionTaskMetrics) -> Void)?
+
+    /// Closure called on the `urlSession(_:task:didCompleteWithError:)` event.
+    open var taskDidComplete: ((URLSession, URLSessionTask, Error?) -> Void)?
+
+    /// Closure called on the `urlSession(_:taskIsWaitingForConnectivity:)` event.
+    open var taskIsWaitingForConnectivity: ((URLSession, URLSessionTask) -> Void)?
+
+    /// Closure that receives the `urlSession(_:dataTask:didReceive:)` event.
+    open var dataTaskDidReceiveData: ((URLSession, URLSessionDataTask, Data) -> Void)?
+
+    /// Closure called on the `urlSession(_:dataTask:willCacheResponse:completionHandler:)` event.
+    open var dataTaskWillCacheResponse: ((URLSession, URLSessionDataTask, CachedURLResponse) -> Void)?
+
+    /// Closure called on the `urlSession(_:downloadTask:didFinishDownloadingTo:)` event.
+    open var downloadTaskDidFinishDownloadingToURL: ((URLSession, URLSessionDownloadTask, URL) -> Void)?
+
+    /// Closure called on the `urlSession(_:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:)`
+    /// event.
+    open var downloadTaskDidWriteData: ((URLSession, URLSessionDownloadTask, Int64, Int64, Int64) -> Void)?
+
+    /// Closure called on the `urlSession(_:downloadTask:didResumeAtOffset:expectedTotalBytes:)` event.
+    open var downloadTaskDidResumeAtOffset: ((URLSession, URLSessionDownloadTask, Int64, Int64) -> Void)?
+
+    // MARK: - Request Events
+
+    /// Closure called on the `request(_:didCreateInitialURLRequest:)` event.
+    open var requestDidCreateInitialURLRequest: ((Request, URLRequest) -> Void)?
+
+    /// Closure called on the `request(_:didFailToCreateURLRequestWithError:)` event.
+    open var requestDidFailToCreateURLRequestWithError: ((Request, AFError) -> Void)?
+
+    /// Closure called on the `request(_:didAdaptInitialRequest:to:)` event.
+    open var requestDidAdaptInitialRequestToAdaptedRequest: ((Request, URLRequest, URLRequest) -> Void)?
+
+    /// Closure called on the `request(_:didFailToAdaptURLRequest:withError:)` event.
+    open var requestDidFailToAdaptURLRequestWithError: ((Request, URLRequest, AFError) -> Void)?
+
+    /// Closure called on the `request(_:didCreateURLRequest:)` event.
+    open var requestDidCreateURLRequest: ((Request, URLRequest) -> Void)?
+
+    /// Closure called on the `request(_:didCreateTask:)` event.
+    open var requestDidCreateTask: ((Request, URLSessionTask) -> Void)?
+
+    /// Closure called on the `request(_:didGatherMetrics:)` event.
+    open var requestDidGatherMetrics: ((Request, URLSessionTaskMetrics) -> Void)?
+
+    /// Closure called on the `request(_:didFailTask:earlyWithError:)` event.
+    open var requestDidFailTaskEarlyWithError: ((Request, URLSessionTask, AFError) -> Void)?
+
+    /// Closure called on the `request(_:didCompleteTask:with:)` event.
+    open var requestDidCompleteTaskWithError: ((Request, URLSessionTask, AFError?) -> Void)?
+
+    /// Closure called on the `requestIsRetrying(_:)` event.
+    open var requestIsRetrying: ((Request) -> Void)?
+
+    /// Closure called on the `requestDidFinish(_:)` event.
+    open var requestDidFinish: ((Request) -> Void)?
+
+    /// Closure called on the `requestDidResume(_:)` event.
+    open var requestDidResume: ((Request) -> Void)?
+
+    /// Closure called on the `request(_:didResumeTask:)` event.
+    open var requestDidResumeTask: ((Request, URLSessionTask) -> Void)?
+
+    /// Closure called on the `requestDidSuspend(_:)` event.
+    open var requestDidSuspend: ((Request) -> Void)?
+
+    /// Closure called on the `request(_:didSuspendTask:)` event.
+    open var requestDidSuspendTask: ((Request, URLSessionTask) -> Void)?
+
+    /// Closure called on the `requestDidCancel(_:)` event.
+    open var requestDidCancel: ((Request) -> Void)?
+
+    /// Closure called on the `request(_:didCancelTask:)` event.
+    open var requestDidCancelTask: ((Request, URLSessionTask) -> Void)?
+
+    /// Closure called on the `request(_:didValidateRequest:response:data:withResult:)` event.
+    open var requestDidValidateRequestResponseDataWithResult: ((DataRequest, URLRequest?, HTTPURLResponse, Data?, Request.ValidationResult) -> Void)?
+
+    /// Closure called on the `request(_:didParseResponse:)` event.
+    open var requestDidParseResponse: ((DataRequest, DataResponse<Data?, AFError>) -> Void)?
+
+    /// Closure called on the `request(_:didValidateRequest:response:withResult:)` event.
+    open var requestDidValidateRequestResponseWithResult: ((DataStreamRequest, URLRequest?, HTTPURLResponse, Request.ValidationResult) -> Void)?
+
+    /// Closure called on the `request(_:didCreateUploadable:)` event.
+    open var requestDidCreateUploadable: ((UploadRequest, UploadRequest.Uploadable) -> Void)?
+
+    /// Closure called on the `request(_:didFailToCreateUploadableWithError:)` event.
+    open var requestDidFailToCreateUploadableWithError: ((UploadRequest, AFError) -> Void)?
+
+    /// Closure called on the `request(_:didProvideInputStream:)` event.
+    open var requestDidProvideInputStream: ((UploadRequest, InputStream) -> Void)?
+
+    /// Closure called on the `request(_:didFinishDownloadingUsing:with:)` event.
+    open var requestDidFinishDownloadingUsingTaskWithResult: ((DownloadRequest, URLSessionTask, Result<URL, AFError>) -> Void)?
+
+    /// Closure called on the `request(_:didCreateDestinationURL:)` event.
+    open var requestDidCreateDestinationURL: ((DownloadRequest, URL) -> Void)?
+
+    /// Closure called on the `request(_:didValidateRequest:response:temporaryURL:destinationURL:withResult:)` event.
+    open var requestDidValidateRequestResponseFileURLWithResult: ((DownloadRequest, URLRequest?, HTTPURLResponse, URL?, Request.ValidationResult) -> Void)?
+
+    /// Closure called on the `request(_:didParseResponse:)` event.
+    open var requestDidParseDownloadResponse: ((DownloadRequest, DownloadResponse<URL?, AFError>) -> Void)?
+
+    public let queue: DispatchQueue
+
+    /// Creates an instance using the provided queue.
+    ///
+    /// - Parameter queue: `DispatchQueue` on which events will fired. `.main` by default.
+    public init(queue: DispatchQueue = .main) {
+        self.queue = queue
+    }
+
+    open func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {
+        sessionDidBecomeInvalidWithError?(session, error)
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge) {
+        taskDidReceiveChallenge?(session, task, challenge)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         didSendBodyData bytesSent: Int64,
+                         totalBytesSent: Int64,
+                         totalBytesExpectedToSend: Int64) {
+        taskDidSendBodyData?(session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)
+    }
+
+    open func urlSession(_ session: URLSession, taskNeedsNewBodyStream task: URLSessionTask) {
+        taskNeedNewBodyStream?(session, task)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         willPerformHTTPRedirection response: HTTPURLResponse,
+                         newRequest request: URLRequest) {
+        taskWillPerformHTTPRedirection?(session, task, response, request)
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
+        taskDidFinishCollectingMetrics?(session, task, metrics)
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        taskDidComplete?(session, task, error)
+    }
+
+    open func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask) {
+        taskIsWaitingForConnectivity?(session, task)
+    }
+
+    open func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        dataTaskDidReceiveData?(session, dataTask, data)
+    }
+
+    open func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, willCacheResponse proposedResponse: CachedURLResponse) {
+        dataTaskWillCacheResponse?(session, dataTask, proposedResponse)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         downloadTask: URLSessionDownloadTask,
+                         didResumeAtOffset fileOffset: Int64,
+                         expectedTotalBytes: Int64) {
+        downloadTaskDidResumeAtOffset?(session, downloadTask, fileOffset, expectedTotalBytes)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         downloadTask: URLSessionDownloadTask,
+                         didWriteData bytesWritten: Int64,
+                         totalBytesWritten: Int64,
+                         totalBytesExpectedToWrite: Int64) {
+        downloadTaskDidWriteData?(session, downloadTask, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)
+    }
+
+    open func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        downloadTaskDidFinishDownloadingToURL?(session, downloadTask, location)
+    }
+
+    // MARK: Request Events
+
+    open func request(_ request: Request, didCreateInitialURLRequest urlRequest: URLRequest) {
+        requestDidCreateInitialURLRequest?(request, urlRequest)
+    }
+
+    open func request(_ request: Request, didFailToCreateURLRequestWithError error: AFError) {
+        requestDidFailToCreateURLRequestWithError?(request, error)
+    }
+
+    open func request(_ request: Request, didAdaptInitialRequest initialRequest: URLRequest, to adaptedRequest: URLRequest) {
+        requestDidAdaptInitialRequestToAdaptedRequest?(request, initialRequest, adaptedRequest)
+    }
+
+    open func request(_ request: Request, didFailToAdaptURLRequest initialRequest: URLRequest, withError error: AFError) {
+        requestDidFailToAdaptURLRequestWithError?(request, initialRequest, error)
+    }
+
+    open func request(_ request: Request, didCreateURLRequest urlRequest: URLRequest) {
+        requestDidCreateURLRequest?(request, urlRequest)
+    }
+
+    open func request(_ request: Request, didCreateTask task: URLSessionTask) {
+        requestDidCreateTask?(request, task)
+    }
+
+    open func request(_ request: Request, didGatherMetrics metrics: URLSessionTaskMetrics) {
+        requestDidGatherMetrics?(request, metrics)
+    }
+
+    open func request(_ request: Request, didFailTask task: URLSessionTask, earlyWithError error: AFError) {
+        requestDidFailTaskEarlyWithError?(request, task, error)
+    }
+
+    open func request(_ request: Request, didCompleteTask task: URLSessionTask, with error: AFError?) {
+        requestDidCompleteTaskWithError?(request, task, error)
+    }
+
+    open func requestIsRetrying(_ request: Request) {
+        requestIsRetrying?(request)
+    }
+
+    open func requestDidFinish(_ request: Request) {
+        requestDidFinish?(request)
+    }
+
+    open func requestDidResume(_ request: Request) {
+        requestDidResume?(request)
+    }
+
+    public func request(_ request: Request, didResumeTask task: URLSessionTask) {
+        requestDidResumeTask?(request, task)
+    }
+
+    open func requestDidSuspend(_ request: Request) {
+        requestDidSuspend?(request)
+    }
+
+    public func request(_ request: Request, didSuspendTask task: URLSessionTask) {
+        requestDidSuspendTask?(request, task)
+    }
+
+    open func requestDidCancel(_ request: Request) {
+        requestDidCancel?(request)
+    }
+
+    public func request(_ request: Request, didCancelTask task: URLSessionTask) {
+        requestDidCancelTask?(request, task)
+    }
+
+    open func request(_ request: DataRequest,
+                      didValidateRequest urlRequest: URLRequest?,
+                      response: HTTPURLResponse,
+                      data: Data?,
+                      withResult result: Request.ValidationResult) {
+        requestDidValidateRequestResponseDataWithResult?(request, urlRequest, response, data, result)
+    }
+
+    open func request(_ request: DataRequest, didParseResponse response: DataResponse<Data?, AFError>) {
+        requestDidParseResponse?(request, response)
+    }
+
+    public func request(_ request: DataStreamRequest, didValidateRequest urlRequest: URLRequest?, response: HTTPURLResponse, withResult result: Request.ValidationResult) {
+        requestDidValidateRequestResponseWithResult?(request, urlRequest, response, result)
+    }
+
+    open func request(_ request: UploadRequest, didCreateUploadable uploadable: UploadRequest.Uploadable) {
+        requestDidCreateUploadable?(request, uploadable)
+    }
+
+    open func request(_ request: UploadRequest, didFailToCreateUploadableWithError error: AFError) {
+        requestDidFailToCreateUploadableWithError?(request, error)
+    }
+
+    open func request(_ request: UploadRequest, didProvideInputStream stream: InputStream) {
+        requestDidProvideInputStream?(request, stream)
+    }
+
+    open func request(_ request: DownloadRequest, didFinishDownloadingUsing task: URLSessionTask, with result: Result<URL, AFError>) {
+        requestDidFinishDownloadingUsingTaskWithResult?(request, task, result)
+    }
+
+    open func request(_ request: DownloadRequest, didCreateDestinationURL url: URL) {
+        requestDidCreateDestinationURL?(request, url)
+    }
+
+    open func request(_ request: DownloadRequest,
+                      didValidateRequest urlRequest: URLRequest?,
+                      response: HTTPURLResponse,
+                      fileURL: URL?,
+                      withResult result: Request.ValidationResult) {
+        requestDidValidateRequestResponseFileURLWithResult?(request,
+                                                            urlRequest,
+                                                            response,
+                                                            fileURL,
+                                                            result)
+    }
+
+    open func request(_ request: DownloadRequest, didParseResponse response: DownloadResponse<URL?, AFError>) {
+        requestDidParseDownloadResponse?(request, response)
+    }
+}

Pods/Alamofire/Source/HTTPHeaders.swift

@@ -0,0 +1,449 @@
+//
+//  HTTPHeaders.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// An order-preserving and case-insensitive representation of HTTP headers.
+public struct HTTPHeaders {
+    private var headers: [HTTPHeader] = []
+
+    /// Creates an empty instance.
+    public init() {}
+
+    /// Creates an instance from an array of `HTTPHeader`s. Duplicate case-insensitive names are collapsed into the last
+    /// name and value encountered.
+    public init(_ headers: [HTTPHeader]) {
+        self.init()
+
+        headers.forEach { update($0) }
+    }
+
+    /// Creates an instance from a `[String: String]`. Duplicate case-insensitive names are collapsed into the last name
+    /// and value encountered.
+    public init(_ dictionary: [String: String]) {
+        self.init()
+
+        dictionary.forEach { update(HTTPHeader(name: $0.key, value: $0.value)) }
+    }
+
+    /// Case-insensitively updates or appends an `HTTPHeader` into the instance using the provided `name` and `value`.
+    ///
+    /// - Parameters:
+    ///   - name:  The `HTTPHeader` name.
+    ///   - value: The `HTTPHeader value.
+    public mutating func add(name: String, value: String) {
+        update(HTTPHeader(name: name, value: value))
+    }
+
+    /// Case-insensitively updates or appends the provided `HTTPHeader` into the instance.
+    ///
+    /// - Parameter header: The `HTTPHeader` to update or append.
+    public mutating func add(_ header: HTTPHeader) {
+        update(header)
+    }
+
+    /// Case-insensitively updates or appends an `HTTPHeader` into the instance using the provided `name` and `value`.
+    ///
+    /// - Parameters:
+    ///   - name:  The `HTTPHeader` name.
+    ///   - value: The `HTTPHeader value.
+    public mutating func update(name: String, value: String) {
+        update(HTTPHeader(name: name, value: value))
+    }
+
+    /// Case-insensitively updates or appends the provided `HTTPHeader` into the instance.
+    ///
+    /// - Parameter header: The `HTTPHeader` to update or append.
+    public mutating func update(_ header: HTTPHeader) {
+        guard let index = headers.index(of: header.name) else {
+            headers.append(header)
+            return
+        }
+
+        headers.replaceSubrange(index...index, with: [header])
+    }
+
+    /// Case-insensitively removes an `HTTPHeader`, if it exists, from the instance.
+    ///
+    /// - Parameter name: The name of the `HTTPHeader` to remove.
+    public mutating func remove(name: String) {
+        guard let index = headers.index(of: name) else { return }
+
+        headers.remove(at: index)
+    }
+
+    /// Sort the current instance by header name, case insensitively.
+    public mutating func sort() {
+        headers.sort { $0.name.lowercased() < $1.name.lowercased() }
+    }
+
+    /// Returns an instance sorted by header name.
+    ///
+    /// - Returns: A copy of the current instance sorted by name.
+    public func sorted() -> HTTPHeaders {
+        var headers = self
+        headers.sort()
+
+        return headers
+    }
+
+    /// Case-insensitively find a header's value by name.
+    ///
+    /// - Parameter name: The name of the header to search for, case-insensitively.
+    ///
+    /// - Returns:        The value of header, if it exists.
+    public func value(for name: String) -> String? {
+        guard let index = headers.index(of: name) else { return nil }
+
+        return headers[index].value
+    }
+
+    /// Case-insensitively access the header with the given name.
+    ///
+    /// - Parameter name: The name of the header.
+    public subscript(_ name: String) -> String? {
+        get { value(for: name) }
+        set {
+            if let value = newValue {
+                update(name: name, value: value)
+            } else {
+                remove(name: name)
+            }
+        }
+    }
+
+    /// The dictionary representation of all headers.
+    ///
+    /// This representation does not preserve the current order of the instance.
+    public var dictionary: [String: String] {
+        let namesAndValues = headers.map { ($0.name, $0.value) }
+
+        return Dictionary(namesAndValues, uniquingKeysWith: { _, last in last })
+    }
+}
+
+extension HTTPHeaders: ExpressibleByDictionaryLiteral {
+    public init(dictionaryLiteral elements: (String, String)...) {
+        self.init()
+
+        elements.forEach { update(name: $0.0, value: $0.1) }
+    }
+}
+
+extension HTTPHeaders: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: HTTPHeader...) {
+        self.init(elements)
+    }
+}
+
+extension HTTPHeaders: Sequence {
+    public func makeIterator() -> IndexingIterator<[HTTPHeader]> {
+        headers.makeIterator()
+    }
+}
+
+extension HTTPHeaders: Collection {
+    public var startIndex: Int {
+        headers.startIndex
+    }
+
+    public var endIndex: Int {
+        headers.endIndex
+    }
+
+    public subscript(position: Int) -> HTTPHeader {
+        headers[position]
+    }
+
+    public func index(after i: Int) -> Int {
+        headers.index(after: i)
+    }
+}
+
+extension HTTPHeaders: CustomStringConvertible {
+    public var description: String {
+        headers.map { $0.description }
+            .joined(separator: "\n")
+    }
+}
+
+// MARK: - HTTPHeader
+
+/// A representation of a single HTTP header's name / value pair.
+public struct HTTPHeader: Hashable {
+    /// Name of the header.
+    public let name: String
+
+    /// Value of the header.
+    public let value: String
+
+    /// Creates an instance from the given `name` and `value`.
+    ///
+    /// - Parameters:
+    ///   - name:  The name of the header.
+    ///   - value: The value of the header.
+    public init(name: String, value: String) {
+        self.name = name
+        self.value = value
+    }
+}
+
+extension HTTPHeader: CustomStringConvertible {
+    public var description: String {
+        "\(name): \(value)"
+    }
+}
+
+extension HTTPHeader {
+    /// Returns an `Accept` header.
+    ///
+    /// - Parameter value: The `Accept` value.
+    /// - Returns:         The header.
+    public static func accept(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Accept", value: value)
+    }
+
+    /// Returns an `Accept-Charset` header.
+    ///
+    /// - Parameter value: The `Accept-Charset` value.
+    /// - Returns:         The header.
+    public static func acceptCharset(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Accept-Charset", value: value)
+    }
+
+    /// Returns an `Accept-Language` header.
+    ///
+    /// Alamofire offers a default Accept-Language header that accumulates and encodes the system's preferred languages.
+    /// Use `HTTPHeader.defaultAcceptLanguage`.
+    ///
+    /// - Parameter value: The `Accept-Language` value.
+    ///
+    /// - Returns:         The header.
+    public static func acceptLanguage(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Accept-Language", value: value)
+    }
+
+    /// Returns an `Accept-Encoding` header.
+    ///
+    /// Alamofire offers a default accept encoding value that provides the most common values. Use
+    /// `HTTPHeader.defaultAcceptEncoding`.
+    ///
+    /// - Parameter value: The `Accept-Encoding` value.
+    ///
+    /// - Returns:         The header
+    public static func acceptEncoding(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Accept-Encoding", value: value)
+    }
+
+    /// Returns a `Basic` `Authorization` header using the `username` and `password` provided.
+    ///
+    /// - Parameters:
+    ///   - username: The username of the header.
+    ///   - password: The password of the header.
+    ///
+    /// - Returns:    The header.
+    public static func authorization(username: String, password: String) -> HTTPHeader {
+        let credential = Data("\(username):\(password)".utf8).base64EncodedString()
+
+        return authorization("Basic \(credential)")
+    }
+
+    /// Returns a `Bearer` `Authorization` header using the `bearerToken` provided
+    ///
+    /// - Parameter bearerToken: The bearer token.
+    ///
+    /// - Returns:               The header.
+    public static func authorization(bearerToken: String) -> HTTPHeader {
+        authorization("Bearer \(bearerToken)")
+    }
+
+    /// Returns an `Authorization` header.
+    ///
+    /// Alamofire provides built-in methods to produce `Authorization` headers. For a Basic `Authorization` header use
+    /// `HTTPHeader.authorization(username:password:)`. For a Bearer `Authorization` header, use
+    /// `HTTPHeader.authorization(bearerToken:)`.
+    ///
+    /// - Parameter value: The `Authorization` value.
+    ///
+    /// - Returns:         The header.
+    public static func authorization(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Authorization", value: value)
+    }
+
+    /// Returns a `Content-Disposition` header.
+    ///
+    /// - Parameter value: The `Content-Disposition` value.
+    ///
+    /// - Returns:         The header.
+    public static func contentDisposition(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Content-Disposition", value: value)
+    }
+
+    /// Returns a `Content-Type` header.
+    ///
+    /// All Alamofire `ParameterEncoding`s and `ParameterEncoder`s set the `Content-Type` of the request, so it may not be necessary to manually
+    /// set this value.
+    ///
+    /// - Parameter value: The `Content-Type` value.
+    ///
+    /// - Returns:         The header.
+    public static func contentType(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "Content-Type", value: value)
+    }
+
+    /// Returns a `User-Agent` header.
+    ///
+    /// - Parameter value: The `User-Agent` value.
+    ///
+    /// - Returns:         The header.
+    public static func userAgent(_ value: String) -> HTTPHeader {
+        HTTPHeader(name: "User-Agent", value: value)
+    }
+}
+
+extension Array where Element == HTTPHeader {
+    /// Case-insensitively finds the index of an `HTTPHeader` with the provided name, if it exists.
+    func index(of name: String) -> Int? {
+        let lowercasedName = name.lowercased()
+        return firstIndex { $0.name.lowercased() == lowercasedName }
+    }
+}
+
+// MARK: - Defaults
+
+extension HTTPHeaders {
+    /// The default set of `HTTPHeaders` used by Alamofire. Includes `Accept-Encoding`, `Accept-Language`, and
+    /// `User-Agent`.
+    public static let `default`: HTTPHeaders = [.defaultAcceptEncoding,
+                                                .defaultAcceptLanguage,
+                                                .defaultUserAgent]
+}
+
+extension HTTPHeader {
+    /// Returns Alamofire's default `Accept-Encoding` header, appropriate for the encodings supported by particular OS
+    /// versions.
+    ///
+    /// See the [Accept-Encoding HTTP header documentation](https://tools.ietf.org/html/rfc7230#section-4.2.3) .
+    public static let defaultAcceptEncoding: HTTPHeader = {
+        let encodings: [String]
+        if #available(iOS 11.0, macOS 10.13, tvOS 11.0, watchOS 4.0, *) {
+            encodings = ["br", "gzip", "deflate"]
+        } else {
+            encodings = ["gzip", "deflate"]
+        }
+
+        return .acceptEncoding(encodings.qualityEncoded())
+    }()
+
+    /// Returns Alamofire's default `Accept-Language` header, generated by querying `Locale` for the user's
+    /// `preferredLanguages`.
+    ///
+    /// See the [Accept-Language HTTP header documentation](https://tools.ietf.org/html/rfc7231#section-5.3.5).
+    public static let defaultAcceptLanguage: HTTPHeader = {
+        .acceptLanguage(Locale.preferredLanguages.prefix(6).qualityEncoded())
+    }()
+
+    /// Returns Alamofire's default `User-Agent` header.
+    ///
+    /// See the [User-Agent header documentation](https://tools.ietf.org/html/rfc7231#section-5.5.3).
+    ///
+    /// Example: `iOS Example/1.0 (org.alamofire.iOS-Example; build:1; iOS 13.0.0) Alamofire/5.0.0`
+    public static let defaultUserAgent: HTTPHeader = {
+        let info = Bundle.main.infoDictionary
+        let executable = (info?["CFBundleExecutable"] as? String) ??
+            (ProcessInfo.processInfo.arguments.first?.split(separator: "/").last.map(String.init)) ??
+            "Unknown"
+        let bundle = info?["CFBundleIdentifier"] as? String ?? "Unknown"
+        let appVersion = info?["CFBundleShortVersionString"] as? String ?? "Unknown"
+        let appBuild = info?["CFBundleVersion"] as? String ?? "Unknown"
+
+        let osNameVersion: String = {
+            let version = ProcessInfo.processInfo.operatingSystemVersion
+            let versionString = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"
+            let osName: String = {
+                #if os(iOS)
+                #if targetEnvironment(macCatalyst)
+                return "macOS(Catalyst)"
+                #else
+                return "iOS"
+                #endif
+                #elseif os(watchOS)
+                return "watchOS"
+                #elseif os(tvOS)
+                return "tvOS"
+                #elseif os(macOS)
+                return "macOS"
+                #elseif os(Linux)
+                return "Linux"
+                #elseif os(Windows)
+                return "Windows"
+                #else
+                return "Unknown"
+                #endif
+            }()
+
+            return "\(osName) \(versionString)"
+        }()
+
+        let alamofireVersion = "Alamofire/\(version)"
+
+        let userAgent = "\(executable)/\(appVersion) (\(bundle); build:\(appBuild); \(osNameVersion)) \(alamofireVersion)"
+
+        return .userAgent(userAgent)
+    }()
+}
+
+extension Collection where Element == String {
+    func qualityEncoded() -> String {
+        enumerated().map { index, encoding in
+            let quality = 1.0 - (Double(index) * 0.1)
+            return "\(encoding);q=\(quality)"
+        }.joined(separator: ", ")
+    }
+}
+
+// MARK: - System Type Extensions
+
+extension URLRequest {
+    /// Returns `allHTTPHeaderFields` as `HTTPHeaders`.
+    public var headers: HTTPHeaders {
+        get { allHTTPHeaderFields.map(HTTPHeaders.init) ?? HTTPHeaders() }
+        set { allHTTPHeaderFields = newValue.dictionary }
+    }
+}
+
+extension HTTPURLResponse {
+    /// Returns `allHeaderFields` as `HTTPHeaders`.
+    public var headers: HTTPHeaders {
+        (allHeaderFields as? [String: String]).map(HTTPHeaders.init) ?? HTTPHeaders()
+    }
+}
+
+extension URLSessionConfiguration {
+    /// Returns `httpAdditionalHeaders` as `HTTPHeaders`.
+    public var headers: HTTPHeaders {
+        get { (httpAdditionalHeaders as? [String: String]).map(HTTPHeaders.init) ?? HTTPHeaders() }
+        set { httpAdditionalHeaders = newValue.dictionary }
+    }
+}

Pods/Alamofire/Source/HTTPMethod.swift

@@ -0,0 +1,54 @@
+//
+//  HTTPMethod.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+/// Type representing HTTP methods. Raw `String` value is stored and compared case-sensitively, so
+/// `HTTPMethod.get != HTTPMethod(rawValue: "get")`.
+///
+/// See https://tools.ietf.org/html/rfc7231#section-4.3
+public struct HTTPMethod: RawRepresentable, Equatable, Hashable {
+    /// `CONNECT` method.
+    public static let connect = HTTPMethod(rawValue: "CONNECT")
+    /// `DELETE` method.
+    public static let delete = HTTPMethod(rawValue: "DELETE")
+    /// `GET` method.
+    public static let get = HTTPMethod(rawValue: "GET")
+    /// `HEAD` method.
+    public static let head = HTTPMethod(rawValue: "HEAD")
+    /// `OPTIONS` method.
+    public static let options = HTTPMethod(rawValue: "OPTIONS")
+    /// `PATCH` method.
+    public static let patch = HTTPMethod(rawValue: "PATCH")
+    /// `POST` method.
+    public static let post = HTTPMethod(rawValue: "POST")
+    /// `PUT` method.
+    public static let put = HTTPMethod(rawValue: "PUT")
+    /// `TRACE` method.
+    public static let trace = HTTPMethod(rawValue: "TRACE")
+
+    public let rawValue: String
+
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+}

Pods/Alamofire/Source/MultipartFormData.swift

@@ -0,0 +1,557 @@
+//
+//  MultipartFormData.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+#if os(iOS) || os(watchOS) || os(tvOS)
+import MobileCoreServices
+#elseif os(macOS)
+import CoreServices
+#endif
+
+/// Constructs `multipart/form-data` for uploads within an HTTP or HTTPS body. There are currently two ways to encode
+/// multipart form data. The first way is to encode the data directly in memory. This is very efficient, but can lead
+/// to memory issues if the dataset is too large. The second way is designed for larger datasets and will write all the
+/// data to a single file on disk with all the proper boundary segmentation. The second approach MUST be used for
+/// larger datasets such as video content, otherwise your app may run out of memory when trying to encode the dataset.
+///
+/// For more information on `multipart/form-data` in general, please refer to the RFC-2388 and RFC-2045 specs as well
+/// and the w3 form documentation.
+///
+/// - https://www.ietf.org/rfc/rfc2388.txt
+/// - https://www.ietf.org/rfc/rfc2045.txt
+/// - https://www.w3.org/TR/html401/interact/forms.html#h-17.13
+open class MultipartFormData {
+    // MARK: - Helper Types
+
+    enum EncodingCharacters {
+        static let crlf = "\r\n"
+    }
+
+    enum BoundaryGenerator {
+        enum BoundaryType {
+            case initial, encapsulated, final
+        }
+
+        static func randomBoundary() -> String {
+            let first = UInt32.random(in: UInt32.min...UInt32.max)
+            let second = UInt32.random(in: UInt32.min...UInt32.max)
+
+            return String(format: "alamofire.boundary.%08x%08x", first, second)
+        }
+
+        static func boundaryData(forBoundaryType boundaryType: BoundaryType, boundary: String) -> Data {
+            let boundaryText: String
+
+            switch boundaryType {
+            case .initial:
+                boundaryText = "--\(boundary)\(EncodingCharacters.crlf)"
+            case .encapsulated:
+                boundaryText = "\(EncodingCharacters.crlf)--\(boundary)\(EncodingCharacters.crlf)"
+            case .final:
+                boundaryText = "\(EncodingCharacters.crlf)--\(boundary)--\(EncodingCharacters.crlf)"
+            }
+
+            return Data(boundaryText.utf8)
+        }
+    }
+
+    class BodyPart {
+        let headers: HTTPHeaders
+        let bodyStream: InputStream
+        let bodyContentLength: UInt64
+        var hasInitialBoundary = false
+        var hasFinalBoundary = false
+
+        init(headers: HTTPHeaders, bodyStream: InputStream, bodyContentLength: UInt64) {
+            self.headers = headers
+            self.bodyStream = bodyStream
+            self.bodyContentLength = bodyContentLength
+        }
+    }
+
+    // MARK: - Properties
+
+    /// Default memory threshold used when encoding `MultipartFormData`, in bytes.
+    public static let encodingMemoryThreshold: UInt64 = 10_000_000
+
+    /// The `Content-Type` header value containing the boundary used to generate the `multipart/form-data`.
+    open lazy var contentType: String = "multipart/form-data; boundary=\(self.boundary)"
+
+    /// The content length of all body parts used to generate the `multipart/form-data` not including the boundaries.
+    public var contentLength: UInt64 { bodyParts.reduce(0) { $0 + $1.bodyContentLength } }
+
+    /// The boundary used to separate the body parts in the encoded form data.
+    public let boundary: String
+
+    let fileManager: FileManager
+
+    private var bodyParts: [BodyPart]
+    private var bodyPartError: AFError?
+    private let streamBufferSize: Int
+
+    // MARK: - Lifecycle
+
+    /// Creates an instance.
+    ///
+    /// - Parameters:
+    ///   - fileManager: `FileManager` to use for file operations, if needed.
+    ///   - boundary: Boundary `String` used to separate body parts.
+    public init(fileManager: FileManager = .default, boundary: String? = nil) {
+        self.fileManager = fileManager
+        self.boundary = boundary ?? BoundaryGenerator.randomBoundary()
+        bodyParts = []
+
+        //
+        // The optimal read/write buffer size in bytes for input and output streams is 1024 (1KB). For more
+        // information, please refer to the following article:
+        //   - https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Streams/Articles/ReadingInputStreams.html
+        //
+        streamBufferSize = 1024
+    }
+
+    // MARK: - Body Parts
+
+    /// Creates a body part from the data and appends it to the instance.
+    ///
+    /// The body part data will be encoded using the following format:
+    ///
+    /// - `Content-Disposition: form-data; name=#{name}; filename=#{filename}` (HTTP Header)
+    /// - `Content-Type: #{mimeType}` (HTTP Header)
+    /// - Encoded file data
+    /// - Multipart form boundary
+    ///
+    /// - Parameters:
+    ///   - data:     `Data` to encoding into the instance.
+    ///   - name:     Name to associate with the `Data` in the `Content-Disposition` HTTP header.
+    ///   - fileName: Filename to associate with the `Data` in the `Content-Disposition` HTTP header.
+    ///   - mimeType: MIME type to associate with the data in the `Content-Type` HTTP header.
+    public func append(_ data: Data, withName name: String, fileName: String? = nil, mimeType: String? = nil) {
+        let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)
+        let stream = InputStream(data: data)
+        let length = UInt64(data.count)
+
+        append(stream, withLength: length, headers: headers)
+    }
+
+    /// Creates a body part from the file and appends it to the instance.
+    ///
+    /// The body part data will be encoded using the following format:
+    ///
+    /// - `Content-Disposition: form-data; name=#{name}; filename=#{generated filename}` (HTTP Header)
+    /// - `Content-Type: #{generated mimeType}` (HTTP Header)
+    /// - Encoded file data
+    /// - Multipart form boundary
+    ///
+    /// The filename in the `Content-Disposition` HTTP header is generated from the last path component of the
+    /// `fileURL`. The `Content-Type` HTTP header MIME type is generated by mapping the `fileURL` extension to the
+    /// system associated MIME type.
+    ///
+    /// - Parameters:
+    ///   - fileURL: `URL` of the file whose content will be encoded into the instance.
+    ///   - name:    Name to associate with the file content in the `Content-Disposition` HTTP header.
+    public func append(_ fileURL: URL, withName name: String) {
+        let fileName = fileURL.lastPathComponent
+        let pathExtension = fileURL.pathExtension
+
+        if !fileName.isEmpty && !pathExtension.isEmpty {
+            let mime = mimeType(forPathExtension: pathExtension)
+            append(fileURL, withName: name, fileName: fileName, mimeType: mime)
+        } else {
+            setBodyPartError(withReason: .bodyPartFilenameInvalid(in: fileURL))
+        }
+    }
+
+    /// Creates a body part from the file and appends it to the instance.
+    ///
+    /// The body part data will be encoded using the following format:
+    ///
+    /// - Content-Disposition: form-data; name=#{name}; filename=#{filename} (HTTP Header)
+    /// - Content-Type: #{mimeType} (HTTP Header)
+    /// - Encoded file data
+    /// - Multipart form boundary
+    ///
+    /// - Parameters:
+    ///   - fileURL:  `URL` of the file whose content will be encoded into the instance.
+    ///   - name:     Name to associate with the file content in the `Content-Disposition` HTTP header.
+    ///   - fileName: Filename to associate with the file content in the `Content-Disposition` HTTP header.
+    ///   - mimeType: MIME type to associate with the file content in the `Content-Type` HTTP header.
+    public func append(_ fileURL: URL, withName name: String, fileName: String, mimeType: String) {
+        let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)
+
+        //============================================================
+        //                 Check 1 - is file URL?
+        //============================================================
+
+        guard fileURL.isFileURL else {
+            setBodyPartError(withReason: .bodyPartURLInvalid(url: fileURL))
+            return
+        }
+
+        //============================================================
+        //              Check 2 - is file URL reachable?
+        //============================================================
+
+        #if !(os(Linux) || os(Windows))
+        do {
+            let isReachable = try fileURL.checkPromisedItemIsReachable()
+            guard isReachable else {
+                setBodyPartError(withReason: .bodyPartFileNotReachable(at: fileURL))
+                return
+            }
+        } catch {
+            setBodyPartError(withReason: .bodyPartFileNotReachableWithError(atURL: fileURL, error: error))
+            return
+        }
+        #endif
+
+        //============================================================
+        //            Check 3 - is file URL a directory?
+        //============================================================
+
+        var isDirectory: ObjCBool = false
+        let path = fileURL.path
+
+        guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory) && !isDirectory.boolValue else {
+            setBodyPartError(withReason: .bodyPartFileIsDirectory(at: fileURL))
+            return
+        }
+
+        //============================================================
+        //          Check 4 - can the file size be extracted?
+        //============================================================
+
+        let bodyContentLength: UInt64
+
+        do {
+            guard let fileSize = try fileManager.attributesOfItem(atPath: path)[.size] as? NSNumber else {
+                setBodyPartError(withReason: .bodyPartFileSizeNotAvailable(at: fileURL))
+                return
+            }
+
+            bodyContentLength = fileSize.uint64Value
+        } catch {
+            setBodyPartError(withReason: .bodyPartFileSizeQueryFailedWithError(forURL: fileURL, error: error))
+            return
+        }
+
+        //============================================================
+        //       Check 5 - can a stream be created from file URL?
+        //============================================================
+
+        guard let stream = InputStream(url: fileURL) else {
+            setBodyPartError(withReason: .bodyPartInputStreamCreationFailed(for: fileURL))
+            return
+        }
+
+        append(stream, withLength: bodyContentLength, headers: headers)
+    }
+
+    /// Creates a body part from the stream and appends it to the instance.
+    ///
+    /// The body part data will be encoded using the following format:
+    ///
+    /// - `Content-Disposition: form-data; name=#{name}; filename=#{filename}` (HTTP Header)
+    /// - `Content-Type: #{mimeType}` (HTTP Header)
+    /// - Encoded stream data
+    /// - Multipart form boundary
+    ///
+    /// - Parameters:
+    ///   - stream:   `InputStream` to encode into the instance.
+    ///   - length:   Length, in bytes, of the stream.
+    ///   - name:     Name to associate with the stream content in the `Content-Disposition` HTTP header.
+    ///   - fileName: Filename to associate with the stream content in the `Content-Disposition` HTTP header.
+    ///   - mimeType: MIME type to associate with the stream content in the `Content-Type` HTTP header.
+    public func append(_ stream: InputStream,
+                       withLength length: UInt64,
+                       name: String,
+                       fileName: String,
+                       mimeType: String) {
+        let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)
+        append(stream, withLength: length, headers: headers)
+    }
+
+    /// Creates a body part with the stream, length, and headers and appends it to the instance.
+    ///
+    /// The body part data will be encoded using the following format:
+    ///
+    /// - HTTP headers
+    /// - Encoded stream data
+    /// - Multipart form boundary
+    ///
+    /// - Parameters:
+    ///   - stream:  `InputStream` to encode into the instance.
+    ///   - length:  Length, in bytes, of the stream.
+    ///   - headers: `HTTPHeaders` for the body part.
+    public func append(_ stream: InputStream, withLength length: UInt64, headers: HTTPHeaders) {
+        let bodyPart = BodyPart(headers: headers, bodyStream: stream, bodyContentLength: length)
+        bodyParts.append(bodyPart)
+    }
+
+    // MARK: - Data Encoding
+
+    /// Encodes all appended body parts into a single `Data` value.
+    ///
+    /// - Note: This method will load all the appended body parts into memory all at the same time. This method should
+    ///         only be used when the encoded data will have a small memory footprint. For large data cases, please use
+    ///         the `writeEncodedData(to:))` method.
+    ///
+    /// - Returns: The encoded `Data`, if encoding is successful.
+    /// - Throws:  An `AFError` if encoding encounters an error.
+    public func encode() throws -> Data {
+        if let bodyPartError = bodyPartError {
+            throw bodyPartError
+        }
+
+        var encoded = Data()
+
+        bodyParts.first?.hasInitialBoundary = true
+        bodyParts.last?.hasFinalBoundary = true
+
+        for bodyPart in bodyParts {
+            let encodedData = try encode(bodyPart)
+            encoded.append(encodedData)
+        }
+
+        return encoded
+    }
+
+    /// Writes all appended body parts to the given file `URL`.
+    ///
+    /// This process is facilitated by reading and writing with input and output streams, respectively. Thus,
+    /// this approach is very memory efficient and should be used for large body part data.
+    ///
+    /// - Parameter fileURL: File `URL` to which to write the form data.
+    /// - Throws:            An `AFError` if encoding encounters an error.
+    public func writeEncodedData(to fileURL: URL) throws {
+        if let bodyPartError = bodyPartError {
+            throw bodyPartError
+        }
+
+        if fileManager.fileExists(atPath: fileURL.path) {
+            throw AFError.multipartEncodingFailed(reason: .outputStreamFileAlreadyExists(at: fileURL))
+        } else if !fileURL.isFileURL {
+            throw AFError.multipartEncodingFailed(reason: .outputStreamURLInvalid(url: fileURL))
+        }
+
+        guard let outputStream = OutputStream(url: fileURL, append: false) else {
+            throw AFError.multipartEncodingFailed(reason: .outputStreamCreationFailed(for: fileURL))
+        }
+
+        outputStream.open()
+        defer { outputStream.close() }
+
+        bodyParts.first?.hasInitialBoundary = true
+        bodyParts.last?.hasFinalBoundary = true
+
+        for bodyPart in bodyParts {
+            try write(bodyPart, to: outputStream)
+        }
+    }
+
+    // MARK: - Private - Body Part Encoding
+
+    private func encode(_ bodyPart: BodyPart) throws -> Data {
+        var encoded = Data()
+
+        let initialData = bodyPart.hasInitialBoundary ? initialBoundaryData() : encapsulatedBoundaryData()
+        encoded.append(initialData)
+
+        let headerData = encodeHeaders(for: bodyPart)
+        encoded.append(headerData)
+
+        let bodyStreamData = try encodeBodyStream(for: bodyPart)
+        encoded.append(bodyStreamData)
+
+        if bodyPart.hasFinalBoundary {
+            encoded.append(finalBoundaryData())
+        }
+
+        return encoded
+    }
+
+    private func encodeHeaders(for bodyPart: BodyPart) -> Data {
+        let headerText = bodyPart.headers.map { "\($0.name): \($0.value)\(EncodingCharacters.crlf)" }
+            .joined()
+            + EncodingCharacters.crlf
+
+        return Data(headerText.utf8)
+    }
+
+    private func encodeBodyStream(for bodyPart: BodyPart) throws -> Data {
+        let inputStream = bodyPart.bodyStream
+        inputStream.open()
+        defer { inputStream.close() }
+
+        var encoded = Data()
+
+        while inputStream.hasBytesAvailable {
+            var buffer = [UInt8](repeating: 0, count: streamBufferSize)
+            let bytesRead = inputStream.read(&buffer, maxLength: streamBufferSize)
+
+            if let error = inputStream.streamError {
+                throw AFError.multipartEncodingFailed(reason: .inputStreamReadFailed(error: error))
+            }
+
+            if bytesRead > 0 {
+                encoded.append(buffer, count: bytesRead)
+            } else {
+                break
+            }
+        }
+
+        guard UInt64(encoded.count) == bodyPart.bodyContentLength else {
+            let error = AFError.UnexpectedInputStreamLength(bytesExpected: bodyPart.bodyContentLength,
+                                                            bytesRead: UInt64(encoded.count))
+            throw AFError.multipartEncodingFailed(reason: .inputStreamReadFailed(error: error))
+        }
+
+        return encoded
+    }
+
+    // MARK: - Private - Writing Body Part to Output Stream
+
+    private func write(_ bodyPart: BodyPart, to outputStream: OutputStream) throws {
+        try writeInitialBoundaryData(for: bodyPart, to: outputStream)
+        try writeHeaderData(for: bodyPart, to: outputStream)
+        try writeBodyStream(for: bodyPart, to: outputStream)
+        try writeFinalBoundaryData(for: bodyPart, to: outputStream)
+    }
+
+    private func writeInitialBoundaryData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
+        let initialData = bodyPart.hasInitialBoundary ? initialBoundaryData() : encapsulatedBoundaryData()
+        return try write(initialData, to: outputStream)
+    }
+
+    private func writeHeaderData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
+        let headerData = encodeHeaders(for: bodyPart)
+        return try write(headerData, to: outputStream)
+    }
+
+    private func writeBodyStream(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
+        let inputStream = bodyPart.bodyStream
+
+        inputStream.open()
+        defer { inputStream.close() }
+
+        while inputStream.hasBytesAvailable {
+            var buffer = [UInt8](repeating: 0, count: streamBufferSize)
+            let bytesRead = inputStream.read(&buffer, maxLength: streamBufferSize)
+
+            if let streamError = inputStream.streamError {
+                throw AFError.multipartEncodingFailed(reason: .inputStreamReadFailed(error: streamError))
+            }
+
+            if bytesRead > 0 {
+                if buffer.count != bytesRead {
+                    buffer = Array(buffer[0..<bytesRead])
+                }
+
+                try write(&buffer, to: outputStream)
+            } else {
+                break
+            }
+        }
+    }
+
+    private func writeFinalBoundaryData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
+        if bodyPart.hasFinalBoundary {
+            return try write(finalBoundaryData(), to: outputStream)
+        }
+    }
+
+    // MARK: - Private - Writing Buffered Data to Output Stream
+
+    private func write(_ data: Data, to outputStream: OutputStream) throws {
+        var buffer = [UInt8](repeating: 0, count: data.count)
+        data.copyBytes(to: &buffer, count: data.count)
+
+        return try write(&buffer, to: outputStream)
+    }
+
+    private func write(_ buffer: inout [UInt8], to outputStream: OutputStream) throws {
+        var bytesToWrite = buffer.count
+
+        while bytesToWrite > 0, outputStream.hasSpaceAvailable {
+            let bytesWritten = outputStream.write(buffer, maxLength: bytesToWrite)
+
+            if let error = outputStream.streamError {
+                throw AFError.multipartEncodingFailed(reason: .outputStreamWriteFailed(error: error))
+            }
+
+            bytesToWrite -= bytesWritten
+
+            if bytesToWrite > 0 {
+                buffer = Array(buffer[bytesWritten..<buffer.count])
+            }
+        }
+    }
+
+    // MARK: - Private - Mime Type
+
+    private func mimeType(forPathExtension pathExtension: String) -> String {
+        #if !(os(Linux) || os(Windows))
+        if
+            let id = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as CFString, nil)?.takeRetainedValue(),
+            let contentType = UTTypeCopyPreferredTagWithClass(id, kUTTagClassMIMEType)?.takeRetainedValue() {
+            return contentType as String
+        }
+        #endif
+
+        return "application/octet-stream"
+    }
+
+    // MARK: - Private - Content Headers
+
+    private func contentHeaders(withName name: String, fileName: String? = nil, mimeType: String? = nil) -> HTTPHeaders {
+        var disposition = "form-data; name=\"\(name)\""
+        if let fileName = fileName { disposition += "; filename=\"\(fileName)\"" }
+
+        var headers: HTTPHeaders = [.contentDisposition(disposition)]
+        if let mimeType = mimeType { headers.add(.contentType(mimeType)) }
+
+        return headers
+    }
+
+    // MARK: - Private - Boundary Encoding
+
+    private func initialBoundaryData() -> Data {
+        BoundaryGenerator.boundaryData(forBoundaryType: .initial, boundary: boundary)
+    }
+
+    private func encapsulatedBoundaryData() -> Data {
+        BoundaryGenerator.boundaryData(forBoundaryType: .encapsulated, boundary: boundary)
+    }
+
+    private func finalBoundaryData() -> Data {
+        BoundaryGenerator.boundaryData(forBoundaryType: .final, boundary: boundary)
+    }
+
+    // MARK: - Private - Errors
+
+    private func setBodyPartError(withReason reason: AFError.MultipartEncodingFailureReason) {
+        guard bodyPartError == nil else { return }
+        bodyPartError = AFError.multipartEncodingFailed(reason: reason)
+    }
+}

Pods/Alamofire/Source/MultipartUpload.swift

@@ -0,0 +1,89 @@
+//
+//  MultipartUpload.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Internal type which encapsulates a `MultipartFormData` upload.
+final class MultipartUpload {
+    lazy var result = Result { try build() }
+
+    @Protected
+    private(set) var multipartFormData: MultipartFormData
+    let encodingMemoryThreshold: UInt64
+    let request: URLRequestConvertible
+    let fileManager: FileManager
+
+    init(encodingMemoryThreshold: UInt64,
+         request: URLRequestConvertible,
+         multipartFormData: MultipartFormData) {
+        self.encodingMemoryThreshold = encodingMemoryThreshold
+        self.request = request
+        fileManager = multipartFormData.fileManager
+        self.multipartFormData = multipartFormData
+    }
+
+    func build() throws -> UploadRequest.Uploadable {
+        let uploadable: UploadRequest.Uploadable
+        if multipartFormData.contentLength < encodingMemoryThreshold {
+            let data = try multipartFormData.encode()
+
+            uploadable = .data(data)
+        } else {
+            let tempDirectoryURL = fileManager.temporaryDirectory
+            let directoryURL = tempDirectoryURL.appendingPathComponent("org.alamofire.manager/multipart.form.data")
+            let fileName = UUID().uuidString
+            let fileURL = directoryURL.appendingPathComponent(fileName)
+
+            try fileManager.createDirectory(at: directoryURL, withIntermediateDirectories: true, attributes: nil)
+
+            do {
+                try multipartFormData.writeEncodedData(to: fileURL)
+            } catch {
+                // Cleanup after attempted write if it fails.
+                try? fileManager.removeItem(at: fileURL)
+                throw error
+            }
+
+            uploadable = .file(fileURL, shouldRemove: true)
+        }
+
+        return uploadable
+    }
+}
+
+extension MultipartUpload: UploadConvertible {
+    func asURLRequest() throws -> URLRequest {
+        var urlRequest = try request.asURLRequest()
+
+        $multipartFormData.read { multipartFormData in
+            urlRequest.headers.add(.contentType(multipartFormData.contentType))
+        }
+
+        return urlRequest
+    }
+
+    func createUploadable() throws -> UploadRequest.Uploadable {
+        try result.get()
+    }
+}

Pods/Alamofire/Source/NetworkReachabilityManager.swift

@@ -0,0 +1,267 @@
+//
+//  NetworkReachabilityManager.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+#if !(os(watchOS) || os(Linux) || os(Windows))
+
+import Foundation
+import SystemConfiguration
+
+/// The `NetworkReachabilityManager` class listens for reachability changes of hosts and addresses for both cellular and
+/// WiFi network interfaces.
+///
+/// Reachability can be used to determine background information about why a network operation failed, or to retry
+/// network requests when a connection is established. It should not be used to prevent a user from initiating a network
+/// request, as it's possible that an initial request may be required to establish reachability.
+open class NetworkReachabilityManager {
+    /// Defines the various states of network reachability.
+    public enum NetworkReachabilityStatus {
+        /// It is unknown whether the network is reachable.
+        case unknown
+        /// The network is not reachable.
+        case notReachable
+        /// The network is reachable on the associated `ConnectionType`.
+        case reachable(ConnectionType)
+
+        init(_ flags: SCNetworkReachabilityFlags) {
+            guard flags.isActuallyReachable else { self = .notReachable; return }
+
+            var networkStatus: NetworkReachabilityStatus = .reachable(.ethernetOrWiFi)
+
+            if flags.isCellular { networkStatus = .reachable(.cellular) }
+
+            self = networkStatus
+        }
+
+        /// Defines the various connection types detected by reachability flags.
+        public enum ConnectionType {
+            /// The connection type is either over Ethernet or WiFi.
+            case ethernetOrWiFi
+            /// The connection type is a cellular connection.
+            case cellular
+        }
+    }
+
+    /// A closure executed when the network reachability status changes. The closure takes a single argument: the
+    /// network reachability status.
+    public typealias Listener = (NetworkReachabilityStatus) -> Void
+
+    /// Default `NetworkReachabilityManager` for the zero address and a `listenerQueue` of `.main`.
+    public static let `default` = NetworkReachabilityManager()
+
+    // MARK: - Properties
+
+    /// Whether the network is currently reachable.
+    open var isReachable: Bool { isReachableOnCellular || isReachableOnEthernetOrWiFi }
+
+    /// Whether the network is currently reachable over the cellular interface.
+    ///
+    /// - Note: Using this property to decide whether to make a high or low bandwidth request is not recommended.
+    ///         Instead, set the `allowsCellularAccess` on any `URLRequest`s being issued.
+    ///
+    open var isReachableOnCellular: Bool { status == .reachable(.cellular) }
+
+    /// Whether the network is currently reachable over Ethernet or WiFi interface.
+    open var isReachableOnEthernetOrWiFi: Bool { status == .reachable(.ethernetOrWiFi) }
+
+    /// `DispatchQueue` on which reachability will update.
+    public let reachabilityQueue = DispatchQueue(label: "org.alamofire.reachabilityQueue")
+
+    /// Flags of the current reachability type, if any.
+    open var flags: SCNetworkReachabilityFlags? {
+        var flags = SCNetworkReachabilityFlags()
+
+        return (SCNetworkReachabilityGetFlags(reachability, &flags)) ? flags : nil
+    }
+
+    /// The current network reachability status.
+    open var status: NetworkReachabilityStatus {
+        flags.map(NetworkReachabilityStatus.init) ?? .unknown
+    }
+
+    /// Mutable state storage.
+    struct MutableState {
+        /// A closure executed when the network reachability status changes.
+        var listener: Listener?
+        /// `DispatchQueue` on which listeners will be called.
+        var listenerQueue: DispatchQueue?
+        /// Previously calculated status.
+        var previousStatus: NetworkReachabilityStatus?
+    }
+
+    /// `SCNetworkReachability` instance providing notifications.
+    private let reachability: SCNetworkReachability
+
+    /// Protected storage for mutable state.
+    @Protected
+    private var mutableState = MutableState()
+
+    // MARK: - Initialization
+
+    /// Creates an instance with the specified host.
+    ///
+    /// - Note: The `host` value must *not* contain a scheme, just the hostname.
+    ///
+    /// - Parameters:
+    ///   - host:          Host used to evaluate network reachability. Must *not* include the scheme (e.g. `https`).
+    public convenience init?(host: String) {
+        guard let reachability = SCNetworkReachabilityCreateWithName(nil, host) else { return nil }
+
+        self.init(reachability: reachability)
+    }
+
+    /// Creates an instance that monitors the address 0.0.0.0.
+    ///
+    /// Reachability treats the 0.0.0.0 address as a special token that causes it to monitor the general routing
+    /// status of the device, both IPv4 and IPv6.
+    public convenience init?() {
+        var zero = sockaddr()
+        zero.sa_len = UInt8(MemoryLayout<sockaddr>.size)
+        zero.sa_family = sa_family_t(AF_INET)
+
+        guard let reachability = SCNetworkReachabilityCreateWithAddress(nil, &zero) else { return nil }
+
+        self.init(reachability: reachability)
+    }
+
+    private init(reachability: SCNetworkReachability) {
+        self.reachability = reachability
+    }
+
+    deinit {
+        stopListening()
+    }
+
+    // MARK: - Listening
+
+    /// Starts listening for changes in network reachability status.
+    ///
+    /// - Note: Stops and removes any existing listener.
+    ///
+    /// - Parameters:
+    ///   - queue:    `DispatchQueue` on which to call the `listener` closure. `.main` by default.
+    ///   - listener: `Listener` closure called when reachability changes.
+    ///
+    /// - Returns: `true` if listening was started successfully, `false` otherwise.
+    @discardableResult
+    open func startListening(onQueue queue: DispatchQueue = .main,
+                             onUpdatePerforming listener: @escaping Listener) -> Bool {
+        stopListening()
+
+        $mutableState.write { state in
+            state.listenerQueue = queue
+            state.listener = listener
+        }
+
+        var context = SCNetworkReachabilityContext(version: 0,
+                                                   info: Unmanaged.passUnretained(self).toOpaque(),
+                                                   retain: nil,
+                                                   release: nil,
+                                                   copyDescription: nil)
+        let callback: SCNetworkReachabilityCallBack = { _, flags, info in
+            guard let info = info else { return }
+
+            let instance = Unmanaged<NetworkReachabilityManager>.fromOpaque(info).takeUnretainedValue()
+            instance.notifyListener(flags)
+        }
+
+        let queueAdded = SCNetworkReachabilitySetDispatchQueue(reachability, reachabilityQueue)
+        let callbackAdded = SCNetworkReachabilitySetCallback(reachability, callback, &context)
+
+        // Manually call listener to give initial state, since the framework may not.
+        if let currentFlags = flags {
+            reachabilityQueue.async {
+                self.notifyListener(currentFlags)
+            }
+        }
+
+        return callbackAdded && queueAdded
+    }
+
+    /// Stops listening for changes in network reachability status.
+    open func stopListening() {
+        SCNetworkReachabilitySetCallback(reachability, nil, nil)
+        SCNetworkReachabilitySetDispatchQueue(reachability, nil)
+        $mutableState.write { state in
+            state.listener = nil
+            state.listenerQueue = nil
+            state.previousStatus = nil
+        }
+    }
+
+    // MARK: - Internal - Listener Notification
+
+    /// Calls the `listener` closure of the `listenerQueue` if the computed status hasn't changed.
+    ///
+    /// - Note: Should only be called from the `reachabilityQueue`.
+    ///
+    /// - Parameter flags: `SCNetworkReachabilityFlags` to use to calculate the status.
+    func notifyListener(_ flags: SCNetworkReachabilityFlags) {
+        let newStatus = NetworkReachabilityStatus(flags)
+
+        $mutableState.write { state in
+            guard state.previousStatus != newStatus else { return }
+
+            state.previousStatus = newStatus
+
+            let listener = state.listener
+            state.listenerQueue?.async { listener?(newStatus) }
+        }
+    }
+}
+
+// MARK: -
+
+extension NetworkReachabilityManager.NetworkReachabilityStatus: Equatable {}
+
+extension SCNetworkReachabilityFlags {
+    var isReachable: Bool { contains(.reachable) }
+    var isConnectionRequired: Bool { contains(.connectionRequired) }
+    var canConnectAutomatically: Bool { contains(.connectionOnDemand) || contains(.connectionOnTraffic) }
+    var canConnectWithoutUserInteraction: Bool { canConnectAutomatically && !contains(.interventionRequired) }
+    var isActuallyReachable: Bool { isReachable && (!isConnectionRequired || canConnectWithoutUserInteraction) }
+    var isCellular: Bool {
+        #if os(iOS) || os(tvOS)
+        return contains(.isWWAN)
+        #else
+        return false
+        #endif
+    }
+
+    /// Human readable `String` for all states, to help with debugging.
+    var readableDescription: String {
+        let W = isCellular ? "W" : "-"
+        let R = isReachable ? "R" : "-"
+        let c = isConnectionRequired ? "c" : "-"
+        let t = contains(.transientConnection) ? "t" : "-"
+        let i = contains(.interventionRequired) ? "i" : "-"
+        let C = contains(.connectionOnTraffic) ? "C" : "-"
+        let D = contains(.connectionOnDemand) ? "D" : "-"
+        let l = contains(.isLocalAddress) ? "l" : "-"
+        let d = contains(.isDirect) ? "d" : "-"
+        let a = contains(.connectionAutomatic) ? "a" : "-"
+
+        return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)\(a)"
+    }
+}
+#endif

Pods/Alamofire/Source/Notifications.swift

@@ -0,0 +1,115 @@
+//
+//  Notifications.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension Request {
+    /// Posted when a `Request` is resumed. The `Notification` contains the resumed `Request`.
+    public static let didResumeNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didResume")
+    /// Posted when a `Request` is suspended. The `Notification` contains the suspended `Request`.
+    public static let didSuspendNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didSuspend")
+    /// Posted when a `Request` is cancelled. The `Notification` contains the cancelled `Request`.
+    public static let didCancelNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didCancel")
+    /// Posted when a `Request` is finished. The `Notification` contains the completed `Request`.
+    public static let didFinishNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didFinish")
+
+    /// Posted when a `URLSessionTask` is resumed. The `Notification` contains the `Request` associated with the `URLSessionTask`.
+    public static let didResumeTaskNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didResumeTask")
+    /// Posted when a `URLSessionTask` is suspended. The `Notification` contains the `Request` associated with the `URLSessionTask`.
+    public static let didSuspendTaskNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didSuspendTask")
+    /// Posted when a `URLSessionTask` is cancelled. The `Notification` contains the `Request` associated with the `URLSessionTask`.
+    public static let didCancelTaskNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didCancelTask")
+    /// Posted when a `URLSessionTask` is completed. The `Notification` contains the `Request` associated with the `URLSessionTask`.
+    public static let didCompleteTaskNotification = Notification.Name(rawValue: "org.alamofire.notification.name.request.didCompleteTask")
+}
+
+// MARK: -
+
+extension Notification {
+    /// The `Request` contained by the instance's `userInfo`, `nil` otherwise.
+    public var request: Request? {
+        userInfo?[String.requestKey] as? Request
+    }
+
+    /// Convenience initializer for a `Notification` containing a `Request` payload.
+    ///
+    /// - Parameters:
+    ///   - name:    The name of the notification.
+    ///   - request: The `Request` payload.
+    init(name: Notification.Name, request: Request) {
+        self.init(name: name, object: nil, userInfo: [String.requestKey: request])
+    }
+}
+
+extension NotificationCenter {
+    /// Convenience function for posting notifications with `Request` payloads.
+    ///
+    /// - Parameters:
+    ///   - name:    The name of the notification.
+    ///   - request: The `Request` payload.
+    func postNotification(named name: Notification.Name, with request: Request) {
+        let notification = Notification(name: name, request: request)
+        post(notification)
+    }
+}
+
+extension String {
+    /// User info dictionary key representing the `Request` associated with the notification.
+    fileprivate static let requestKey = "org.alamofire.notification.key.request"
+}
+
+/// `EventMonitor` that provides Alamofire's notifications.
+public final class AlamofireNotifications: EventMonitor {
+    public func requestDidResume(_ request: Request) {
+        NotificationCenter.default.postNotification(named: Request.didResumeNotification, with: request)
+    }
+
+    public func requestDidSuspend(_ request: Request) {
+        NotificationCenter.default.postNotification(named: Request.didSuspendNotification, with: request)
+    }
+
+    public func requestDidCancel(_ request: Request) {
+        NotificationCenter.default.postNotification(named: Request.didCancelNotification, with: request)
+    }
+
+    public func requestDidFinish(_ request: Request) {
+        NotificationCenter.default.postNotification(named: Request.didFinishNotification, with: request)
+    }
+
+    public func request(_ request: Request, didResumeTask task: URLSessionTask) {
+        NotificationCenter.default.postNotification(named: Request.didResumeTaskNotification, with: request)
+    }
+
+    public func request(_ request: Request, didSuspendTask task: URLSessionTask) {
+        NotificationCenter.default.postNotification(named: Request.didSuspendTaskNotification, with: request)
+    }
+
+    public func request(_ request: Request, didCancelTask task: URLSessionTask) {
+        NotificationCenter.default.postNotification(named: Request.didCancelTaskNotification, with: request)
+    }
+
+    public func request(_ request: Request, didCompleteTask task: URLSessionTask, with error: AFError?) {
+        NotificationCenter.default.postNotification(named: Request.didCompleteTaskNotification, with: request)
+    }
+}

Pods/Alamofire/Source/OperationQueue+Alamofire.swift

@@ -0,0 +1,49 @@
+//
+//  OperationQueue+Alamofire.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension OperationQueue {
+    /// Creates an instance using the provided parameters.
+    ///
+    /// - Parameters:
+    ///   - qualityOfService:            `QualityOfService` to be applied to the queue. `.default` by default.
+    ///   - maxConcurrentOperationCount: Maximum concurrent operations.
+    ///                                  `OperationQueue.defaultMaxConcurrentOperationCount` by default.
+    ///   - underlyingQueue: Underlying  `DispatchQueue`. `nil` by default.
+    ///   - name:                        Name for the queue. `nil` by default.
+    ///   - startSuspended:              Whether the queue starts suspended. `false` by default.
+    convenience init(qualityOfService: QualityOfService = .default,
+                     maxConcurrentOperationCount: Int = OperationQueue.defaultMaxConcurrentOperationCount,
+                     underlyingQueue: DispatchQueue? = nil,
+                     name: String? = nil,
+                     startSuspended: Bool = false) {
+        self.init()
+        self.qualityOfService = qualityOfService
+        self.maxConcurrentOperationCount = maxConcurrentOperationCount
+        self.underlyingQueue = underlyingQueue
+        self.name = name
+        isSuspended = startSuspended
+    }
+}

Pods/Alamofire/Source/ParameterEncoder.swift

@@ -0,0 +1,184 @@
+//
+//  ParameterEncoder.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A type that can encode any `Encodable` type into a `URLRequest`.
+public protocol ParameterEncoder {
+    /// Encode the provided `Encodable` parameters into `request`.
+    ///
+    /// - Parameters:
+    ///   - parameters: The `Encodable` parameter value.
+    ///   - request:    The `URLRequest` into which to encode the parameters.
+    ///
+    /// - Returns:      A `URLRequest` with the result of the encoding.
+    /// - Throws:       An `Error` when encoding fails. For Alamofire provided encoders, this will be an instance of
+    ///                 `AFError.parameterEncoderFailed` with an associated `ParameterEncoderFailureReason`.
+    func encode<Parameters: Encodable>(_ parameters: Parameters?, into request: URLRequest) throws -> URLRequest
+}
+
+/// A `ParameterEncoder` that encodes types as JSON body data.
+///
+/// If no `Content-Type` header is already set on the provided `URLRequest`s, it's set to `application/json`.
+open class JSONParameterEncoder: ParameterEncoder {
+    /// Returns an encoder with default parameters.
+    public static var `default`: JSONParameterEncoder { JSONParameterEncoder() }
+
+    /// Returns an encoder with `JSONEncoder.outputFormatting` set to `.prettyPrinted`.
+    public static var prettyPrinted: JSONParameterEncoder {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .prettyPrinted
+
+        return JSONParameterEncoder(encoder: encoder)
+    }
+
+    /// Returns an encoder with `JSONEncoder.outputFormatting` set to `.sortedKeys`.
+    @available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)
+    public static var sortedKeys: JSONParameterEncoder {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .sortedKeys
+
+        return JSONParameterEncoder(encoder: encoder)
+    }
+
+    /// `JSONEncoder` used to encode parameters.
+    public let encoder: JSONEncoder
+
+    /// Creates an instance with the provided `JSONEncoder`.
+    ///
+    /// - Parameter encoder: The `JSONEncoder`. `JSONEncoder()` by default.
+    public init(encoder: JSONEncoder = JSONEncoder()) {
+        self.encoder = encoder
+    }
+
+    open func encode<Parameters: Encodable>(_ parameters: Parameters?,
+                                            into request: URLRequest) throws -> URLRequest {
+        guard let parameters = parameters else { return request }
+
+        var request = request
+
+        do {
+            let data = try encoder.encode(parameters)
+            request.httpBody = data
+            if request.headers["Content-Type"] == nil {
+                request.headers.update(.contentType("application/json"))
+            }
+        } catch {
+            throw AFError.parameterEncodingFailed(reason: .jsonEncodingFailed(error: error))
+        }
+
+        return request
+    }
+}
+
+/// A `ParameterEncoder` that encodes types as URL-encoded query strings to be set on the URL or as body data, depending
+/// on the `Destination` set.
+///
+/// If no `Content-Type` header is already set on the provided `URLRequest`s, it will be set to
+/// `application/x-www-form-urlencoded; charset=utf-8`.
+///
+/// Encoding behavior can be customized by passing an instance of `URLEncodedFormEncoder` to the initializer.
+open class URLEncodedFormParameterEncoder: ParameterEncoder {
+    /// Defines where the URL-encoded string should be set for each `URLRequest`.
+    public enum Destination {
+        /// Applies the encoded query string to any existing query string for `.get`, `.head`, and `.delete` request.
+        /// Sets it to the `httpBody` for all other methods.
+        case methodDependent
+        /// Applies the encoded query string to any existing query string from the `URLRequest`.
+        case queryString
+        /// Applies the encoded query string to the `httpBody` of the `URLRequest`.
+        case httpBody
+
+        /// Determines whether the URL-encoded string should be applied to the `URLRequest`'s `url`.
+        ///
+        /// - Parameter method: The `HTTPMethod`.
+        ///
+        /// - Returns:          Whether the URL-encoded string should be applied to a `URL`.
+        func encodesParametersInURL(for method: HTTPMethod) -> Bool {
+            switch self {
+            case .methodDependent: return [.get, .head, .delete].contains(method)
+            case .queryString: return true
+            case .httpBody: return false
+            }
+        }
+    }
+
+    /// Returns an encoder with default parameters.
+    public static var `default`: URLEncodedFormParameterEncoder { URLEncodedFormParameterEncoder() }
+
+    /// The `URLEncodedFormEncoder` to use.
+    public let encoder: URLEncodedFormEncoder
+
+    /// The `Destination` for the URL-encoded string.
+    public let destination: Destination
+
+    /// Creates an instance with the provided `URLEncodedFormEncoder` instance and `Destination` value.
+    ///
+    /// - Parameters:
+    ///   - encoder:     The `URLEncodedFormEncoder`. `URLEncodedFormEncoder()` by default.
+    ///   - destination: The `Destination`. `.methodDependent` by default.
+    public init(encoder: URLEncodedFormEncoder = URLEncodedFormEncoder(), destination: Destination = .methodDependent) {
+        self.encoder = encoder
+        self.destination = destination
+    }
+
+    open func encode<Parameters: Encodable>(_ parameters: Parameters?,
+                                            into request: URLRequest) throws -> URLRequest {
+        guard let parameters = parameters else { return request }
+
+        var request = request
+
+        guard let url = request.url else {
+            throw AFError.parameterEncoderFailed(reason: .missingRequiredComponent(.url))
+        }
+
+        guard let method = request.method else {
+            let rawValue = request.method?.rawValue ?? "nil"
+            throw AFError.parameterEncoderFailed(reason: .missingRequiredComponent(.httpMethod(rawValue: rawValue)))
+        }
+
+        if destination.encodesParametersInURL(for: method),
+           var components = URLComponents(url: url, resolvingAgainstBaseURL: false) {
+            let query: String = try Result<String, Error> { try encoder.encode(parameters) }
+                .mapError { AFError.parameterEncoderFailed(reason: .encoderFailed(error: $0)) }.get()
+            let newQueryString = [components.percentEncodedQuery, query].compactMap { $0 }.joinedWithAmpersands()
+            components.percentEncodedQuery = newQueryString.isEmpty ? nil : newQueryString
+
+            guard let newURL = components.url else {
+                throw AFError.parameterEncoderFailed(reason: .missingRequiredComponent(.url))
+            }
+
+            request.url = newURL
+        } else {
+            if request.headers["Content-Type"] == nil {
+                request.headers.update(.contentType("application/x-www-form-urlencoded; charset=utf-8"))
+            }
+
+            request.httpBody = try Result<Data, Error> { try encoder.encode(parameters) }
+                .mapError { AFError.parameterEncoderFailed(reason: .encoderFailed(error: $0)) }.get()
+        }
+
+        return request
+    }
+}

Pods/Alamofire/Source/ParameterEncoding.swift

@@ -0,0 +1,317 @@
+//
+//  ParameterEncoding.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A dictionary of parameters to apply to a `URLRequest`.
+public typealias Parameters = [String: Any]
+
+/// A type used to define how a set of parameters are applied to a `URLRequest`.
+public protocol ParameterEncoding {
+    /// Creates a `URLRequest` by encoding parameters and applying them on the passed request.
+    ///
+    /// - Parameters:
+    ///   - urlRequest: `URLRequestConvertible` value onto which parameters will be encoded.
+    ///   - parameters: `Parameters` to encode onto the request.
+    ///
+    /// - Returns:      The encoded `URLRequest`.
+    /// - Throws:       Any `Error` produced during parameter encoding.
+    func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest
+}
+
+// MARK: -
+
+/// Creates a url-encoded query string to be set as or appended to any existing URL query string or set as the HTTP
+/// body of the URL request. Whether the query string is set or appended to any existing URL query string or set as
+/// the HTTP body depends on the destination of the encoding.
+///
+/// The `Content-Type` HTTP header field of an encoded request with HTTP body is set to
+/// `application/x-www-form-urlencoded; charset=utf-8`.
+///
+/// There is no published specification for how to encode collection types. By default the convention of appending
+/// `[]` to the key for array values (`foo[]=1&foo[]=2`), and appending the key surrounded by square brackets for
+/// nested dictionary values (`foo[bar]=baz`) is used. Optionally, `ArrayEncoding` can be used to omit the
+/// square brackets appended to array keys.
+///
+/// `BoolEncoding` can be used to configure how boolean values are encoded. The default behavior is to encode
+/// `true` as 1 and `false` as 0.
+public struct URLEncoding: ParameterEncoding {
+    // MARK: Helper Types
+
+    /// Defines whether the url-encoded query string is applied to the existing query string or HTTP body of the
+    /// resulting URL request.
+    public enum Destination {
+        /// Applies encoded query string result to existing query string for `GET`, `HEAD` and `DELETE` requests and
+        /// sets as the HTTP body for requests with any other HTTP method.
+        case methodDependent
+        /// Sets or appends encoded query string result to existing query string.
+        case queryString
+        /// Sets encoded query string result as the HTTP body of the URL request.
+        case httpBody
+
+        func encodesParametersInURL(for method: HTTPMethod) -> Bool {
+            switch self {
+            case .methodDependent: return [.get, .head, .delete].contains(method)
+            case .queryString: return true
+            case .httpBody: return false
+            }
+        }
+    }
+
+    /// Configures how `Array` parameters are encoded.
+    public enum ArrayEncoding {
+        /// An empty set of square brackets is appended to the key for every value. This is the default behavior.
+        case brackets
+        /// No brackets are appended. The key is encoded as is.
+        case noBrackets
+
+        func encode(key: String) -> String {
+            switch self {
+            case .brackets:
+                return "\(key)[]"
+            case .noBrackets:
+                return key
+            }
+        }
+    }
+
+    /// Configures how `Bool` parameters are encoded.
+    public enum BoolEncoding {
+        /// Encode `true` as `1` and `false` as `0`. This is the default behavior.
+        case numeric
+        /// Encode `true` and `false` as string literals.
+        case literal
+
+        func encode(value: Bool) -> String {
+            switch self {
+            case .numeric:
+                return value ? "1" : "0"
+            case .literal:
+                return value ? "true" : "false"
+            }
+        }
+    }
+
+    // MARK: Properties
+
+    /// Returns a default `URLEncoding` instance with a `.methodDependent` destination.
+    public static var `default`: URLEncoding { URLEncoding() }
+
+    /// Returns a `URLEncoding` instance with a `.queryString` destination.
+    public static var queryString: URLEncoding { URLEncoding(destination: .queryString) }
+
+    /// Returns a `URLEncoding` instance with an `.httpBody` destination.
+    public static var httpBody: URLEncoding { URLEncoding(destination: .httpBody) }
+
+    /// The destination defining where the encoded query string is to be applied to the URL request.
+    public let destination: Destination
+
+    /// The encoding to use for `Array` parameters.
+    public let arrayEncoding: ArrayEncoding
+
+    /// The encoding to use for `Bool` parameters.
+    public let boolEncoding: BoolEncoding
+
+    // MARK: Initialization
+
+    /// Creates an instance using the specified parameters.
+    ///
+    /// - Parameters:
+    ///   - destination:   `Destination` defining where the encoded query string will be applied. `.methodDependent` by
+    ///                    default.
+    ///   - arrayEncoding: `ArrayEncoding` to use. `.brackets` by default.
+    ///   - boolEncoding:  `BoolEncoding` to use. `.numeric` by default.
+    public init(destination: Destination = .methodDependent,
+                arrayEncoding: ArrayEncoding = .brackets,
+                boolEncoding: BoolEncoding = .numeric) {
+        self.destination = destination
+        self.arrayEncoding = arrayEncoding
+        self.boolEncoding = boolEncoding
+    }
+
+    // MARK: Encoding
+
+    public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
+        var urlRequest = try urlRequest.asURLRequest()
+
+        guard let parameters = parameters else { return urlRequest }
+
+        if let method = urlRequest.method, destination.encodesParametersInURL(for: method) {
+            guard let url = urlRequest.url else {
+                throw AFError.parameterEncodingFailed(reason: .missingURL)
+            }
+
+            if var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false), !parameters.isEmpty {
+                let percentEncodedQuery = (urlComponents.percentEncodedQuery.map { $0 + "&" } ?? "") + query(parameters)
+                urlComponents.percentEncodedQuery = percentEncodedQuery
+                urlRequest.url = urlComponents.url
+            }
+        } else {
+            if urlRequest.headers["Content-Type"] == nil {
+                urlRequest.headers.update(.contentType("application/x-www-form-urlencoded; charset=utf-8"))
+            }
+
+            urlRequest.httpBody = Data(query(parameters).utf8)
+        }
+
+        return urlRequest
+    }
+
+    /// Creates a percent-escaped, URL encoded query string components from the given key-value pair recursively.
+    ///
+    /// - Parameters:
+    ///   - key:   Key of the query component.
+    ///   - value: Value of the query component.
+    ///
+    /// - Returns: The percent-escaped, URL encoded query string components.
+    public func queryComponents(fromKey key: String, value: Any) -> [(String, String)] {
+        var components: [(String, String)] = []
+        switch value {
+        case let dictionary as [String: Any]:
+            for (nestedKey, value) in dictionary {
+                components += queryComponents(fromKey: "\(key)[\(nestedKey)]", value: value)
+            }
+        case let array as [Any]:
+            for value in array {
+                components += queryComponents(fromKey: arrayEncoding.encode(key: key), value: value)
+            }
+        case let number as NSNumber:
+            if number.isBool {
+                components.append((escape(key), escape(boolEncoding.encode(value: number.boolValue))))
+            } else {
+                components.append((escape(key), escape("\(number)")))
+            }
+        case let bool as Bool:
+            components.append((escape(key), escape(boolEncoding.encode(value: bool))))
+        default:
+            components.append((escape(key), escape("\(value)")))
+        }
+        return components
+    }
+
+    /// Creates a percent-escaped string following RFC 3986 for a query string key or value.
+    ///
+    /// - Parameter string: `String` to be percent-escaped.
+    ///
+    /// - Returns:          The percent-escaped `String`.
+    public func escape(_ string: String) -> String {
+        string.addingPercentEncoding(withAllowedCharacters: .afURLQueryAllowed) ?? string
+    }
+
+    private func query(_ parameters: [String: Any]) -> String {
+        var components: [(String, String)] = []
+
+        for key in parameters.keys.sorted(by: <) {
+            let value = parameters[key]!
+            components += queryComponents(fromKey: key, value: value)
+        }
+        return components.map { "\($0)=\($1)" }.joined(separator: "&")
+    }
+}
+
+// MARK: -
+
+/// Uses `JSONSerialization` to create a JSON representation of the parameters object, which is set as the body of the
+/// request. The `Content-Type` HTTP header field of an encoded request is set to `application/json`.
+public struct JSONEncoding: ParameterEncoding {
+    // MARK: Properties
+
+    /// Returns a `JSONEncoding` instance with default writing options.
+    public static var `default`: JSONEncoding { JSONEncoding() }
+
+    /// Returns a `JSONEncoding` instance with `.prettyPrinted` writing options.
+    public static var prettyPrinted: JSONEncoding { JSONEncoding(options: .prettyPrinted) }
+
+    /// The options for writing the parameters as JSON data.
+    public let options: JSONSerialization.WritingOptions
+
+    // MARK: Initialization
+
+    /// Creates an instance using the specified `WritingOptions`.
+    ///
+    /// - Parameter options: `JSONSerialization.WritingOptions` to use.
+    public init(options: JSONSerialization.WritingOptions = []) {
+        self.options = options
+    }
+
+    // MARK: Encoding
+
+    public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
+        var urlRequest = try urlRequest.asURLRequest()
+
+        guard let parameters = parameters else { return urlRequest }
+
+        do {
+            let data = try JSONSerialization.data(withJSONObject: parameters, options: options)
+
+            if urlRequest.headers["Content-Type"] == nil {
+                urlRequest.headers.update(.contentType("application/json"))
+            }
+
+            urlRequest.httpBody = data
+        } catch {
+            throw AFError.parameterEncodingFailed(reason: .jsonEncodingFailed(error: error))
+        }
+
+        return urlRequest
+    }
+
+    /// Encodes any JSON compatible object into a `URLRequest`.
+    ///
+    /// - Parameters:
+    ///   - urlRequest: `URLRequestConvertible` value into which the object will be encoded.
+    ///   - jsonObject: `Any` value (must be JSON compatible` to be encoded into the `URLRequest`. `nil` by default.
+    ///
+    /// - Returns:      The encoded `URLRequest`.
+    /// - Throws:       Any `Error` produced during encoding.
+    public func encode(_ urlRequest: URLRequestConvertible, withJSONObject jsonObject: Any? = nil) throws -> URLRequest {
+        var urlRequest = try urlRequest.asURLRequest()
+
+        guard let jsonObject = jsonObject else { return urlRequest }
+
+        do {
+            let data = try JSONSerialization.data(withJSONObject: jsonObject, options: options)
+
+            if urlRequest.headers["Content-Type"] == nil {
+                urlRequest.headers.update(.contentType("application/json"))
+            }
+
+            urlRequest.httpBody = data
+        } catch {
+            throw AFError.parameterEncodingFailed(reason: .jsonEncodingFailed(error: error))
+        }
+
+        return urlRequest
+    }
+}
+
+// MARK: -
+
+extension NSNumber {
+    fileprivate var isBool: Bool {
+        // Use Obj-C type encoding to check whether the underlying type is a `Bool`, as it's guaranteed as part of
+        // swift-corelibs-foundation, per [this discussion on the Swift forums](https://forums.swift.org/t/alamofire-on-linux-possible-but-not-release-ready/34553/22).
+        String(cString: objCType) == "c"
+    }
+}

Pods/Alamofire/Source/Protected.swift

@@ -0,0 +1,197 @@
+//
+//  Protected.swift
+//
+//  Copyright (c) 2014-2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+private protocol Lock {
+    func lock()
+    func unlock()
+}
+
+extension Lock {
+    /// Executes a closure returning a value while acquiring the lock.
+    ///
+    /// - Parameter closure: The closure to run.
+    ///
+    /// - Returns:           The value the closure generated.
+    func around<T>(_ closure: () -> T) -> T {
+        lock(); defer { unlock() }
+        return closure()
+    }
+
+    /// Execute a closure while acquiring the lock.
+    ///
+    /// - Parameter closure: The closure to run.
+    func around(_ closure: () -> Void) {
+        lock(); defer { unlock() }
+        closure()
+    }
+}
+
+#if os(Linux) || os(Windows)
+
+extension NSLock: Lock {}
+
+#endif
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+/// An `os_unfair_lock` wrapper.
+final class UnfairLock: Lock {
+    private let unfairLock: os_unfair_lock_t
+
+    init() {
+        unfairLock = .allocate(capacity: 1)
+        unfairLock.initialize(to: os_unfair_lock())
+    }
+
+    deinit {
+        unfairLock.deinitialize(count: 1)
+        unfairLock.deallocate()
+    }
+
+    fileprivate func lock() {
+        os_unfair_lock_lock(unfairLock)
+    }
+
+    fileprivate func unlock() {
+        os_unfair_lock_unlock(unfairLock)
+    }
+}
+#endif
+
+/// A thread-safe wrapper around a value.
+@propertyWrapper
+@dynamicMemberLookup
+final class Protected<T> {
+    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+    private let lock = UnfairLock()
+    #elseif os(Linux) || os(Windows)
+    private let lock = NSLock()
+    #endif
+    private var value: T
+
+    init(_ value: T) {
+        self.value = value
+    }
+
+    /// The contained value. Unsafe for anything more than direct read or write.
+    var wrappedValue: T {
+        get { lock.around { value } }
+        set { lock.around { value = newValue } }
+    }
+
+    var projectedValue: Protected<T> { self }
+
+    init(wrappedValue: T) {
+        value = wrappedValue
+    }
+
+    /// Synchronously read or transform the contained value.
+    ///
+    /// - Parameter closure: The closure to execute.
+    ///
+    /// - Returns:           The return value of the closure passed.
+    func read<U>(_ closure: (T) -> U) -> U {
+        lock.around { closure(self.value) }
+    }
+
+    /// Synchronously modify the protected value.
+    ///
+    /// - Parameter closure: The closure to execute.
+    ///
+    /// - Returns:           The modified value.
+    @discardableResult
+    func write<U>(_ closure: (inout T) -> U) -> U {
+        lock.around { closure(&self.value) }
+    }
+
+    subscript<Property>(dynamicMember keyPath: WritableKeyPath<T, Property>) -> Property {
+        get { lock.around { value[keyPath: keyPath] } }
+        set { lock.around { value[keyPath: keyPath] = newValue } }
+    }
+}
+
+extension Protected where T: RangeReplaceableCollection {
+    /// Adds a new element to the end of this protected collection.
+    ///
+    /// - Parameter newElement: The `Element` to append.
+    func append(_ newElement: T.Element) {
+        write { (ward: inout T) in
+            ward.append(newElement)
+        }
+    }
+
+    /// Adds the elements of a sequence to the end of this protected collection.
+    ///
+    /// - Parameter newElements: The `Sequence` to append.
+    func append<S: Sequence>(contentsOf newElements: S) where S.Element == T.Element {
+        write { (ward: inout T) in
+            ward.append(contentsOf: newElements)
+        }
+    }
+
+    /// Add the elements of a collection to the end of the protected collection.
+    ///
+    /// - Parameter newElements: The `Collection` to append.
+    func append<C: Collection>(contentsOf newElements: C) where C.Element == T.Element {
+        write { (ward: inout T) in
+            ward.append(contentsOf: newElements)
+        }
+    }
+}
+
+extension Protected where T == Data? {
+    /// Adds the contents of a `Data` value to the end of the protected `Data`.
+    ///
+    /// - Parameter data: The `Data` to be appended.
+    func append(_ data: Data) {
+        write { (ward: inout T) in
+            ward?.append(data)
+        }
+    }
+}
+
+extension Protected where T == Request.MutableState {
+    /// Attempts to transition to the passed `State`.
+    ///
+    /// - Parameter state: The `State` to attempt transition to.
+    ///
+    /// - Returns:         Whether the transition occurred.
+    func attemptToTransitionTo(_ state: Request.State) -> Bool {
+        lock.around {
+            guard value.state.canTransitionTo(state) else { return false }
+
+            value.state = state
+
+            return true
+        }
+    }
+
+    /// Perform a closure while locked with the provided `Request.State`.
+    ///
+    /// - Parameter perform: The closure to perform while locked.
+    func withState(perform: (Request.State) -> Void) {
+        lock.around { perform(value.state) }
+    }
+}

Pods/Alamofire/Source/RedirectHandler.swift

@@ -0,0 +1,95 @@
+//
+//  RedirectHandler.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A type that handles how an HTTP redirect response from a remote server should be redirected to the new request.
+public protocol RedirectHandler {
+    /// Determines how the HTTP redirect response should be redirected to the new request.
+    ///
+    /// The `completion` closure should be passed one of three possible options:
+    ///
+    ///   1. The new request specified by the redirect (this is the most common use case).
+    ///   2. A modified version of the new request (you may want to route it somewhere else).
+    ///   3. A `nil` value to deny the redirect request and return the body of the redirect response.
+    ///
+    /// - Parameters:
+    ///   - task:       The `URLSessionTask` whose request resulted in a redirect.
+    ///   - request:    The `URLRequest` to the new location specified by the redirect response.
+    ///   - response:   The `HTTPURLResponse` containing the server's response to the original request.
+    ///   - completion: The closure to execute containing the new `URLRequest`, a modified `URLRequest`, or `nil`.
+    func task(_ task: URLSessionTask,
+              willBeRedirectedTo request: URLRequest,
+              for response: HTTPURLResponse,
+              completion: @escaping (URLRequest?) -> Void)
+}
+
+// MARK: -
+
+/// `Redirector` is a convenience `RedirectHandler` making it easy to follow, not follow, or modify a redirect.
+public struct Redirector {
+    /// Defines the behavior of the `Redirector` type.
+    public enum Behavior {
+        /// Follow the redirect as defined in the response.
+        case follow
+        /// Do not follow the redirect defined in the response.
+        case doNotFollow
+        /// Modify the redirect request defined in the response.
+        case modify((URLSessionTask, URLRequest, HTTPURLResponse) -> URLRequest?)
+    }
+
+    /// Returns a `Redirector` with a `.follow` `Behavior`.
+    public static let follow = Redirector(behavior: .follow)
+    /// Returns a `Redirector` with a `.doNotFollow` `Behavior`.
+    public static let doNotFollow = Redirector(behavior: .doNotFollow)
+
+    /// The `Behavior` of the `Redirector`.
+    public let behavior: Behavior
+
+    /// Creates a `Redirector` instance from the `Behavior`.
+    ///
+    /// - Parameter behavior: The `Behavior`.
+    public init(behavior: Behavior) {
+        self.behavior = behavior
+    }
+}
+
+// MARK: -
+
+extension Redirector: RedirectHandler {
+    public func task(_ task: URLSessionTask,
+                     willBeRedirectedTo request: URLRequest,
+                     for response: HTTPURLResponse,
+                     completion: @escaping (URLRequest?) -> Void) {
+        switch behavior {
+        case .follow:
+            completion(request)
+        case .doNotFollow:
+            completion(nil)
+        case let .modify(closure):
+            let request = closure(task, request, response)
+            completion(request)
+        }
+    }
+}

Pods/Alamofire/Source/Request.swift

@@ -0,0 +1,1893 @@
+//
+//  Request.swift
+//
+//  Copyright (c) 2014-2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// `Request` is the common superclass of all Alamofire request types and provides common state, delegate, and callback
+/// handling.
+public class Request {
+    /// State of the `Request`, with managed transitions between states set when calling `resume()`, `suspend()`, or
+    /// `cancel()` on the `Request`.
+    public enum State {
+        /// Initial state of the `Request`.
+        case initialized
+        /// `State` set when `resume()` is called. Any tasks created for the `Request` will have `resume()` called on
+        /// them in this state.
+        case resumed
+        /// `State` set when `suspend()` is called. Any tasks created for the `Request` will have `suspend()` called on
+        /// them in this state.
+        case suspended
+        /// `State` set when `cancel()` is called. Any tasks created for the `Request` will have `cancel()` called on
+        /// them. Unlike `resumed` or `suspended`, once in the `cancelled` state, the `Request` can no longer transition
+        /// to any other state.
+        case cancelled
+        /// `State` set when all response serialization completion closures have been cleared on the `Request` and
+        /// enqueued on their respective queues.
+        case finished
+
+        /// Determines whether `self` can be transitioned to the provided `State`.
+        func canTransitionTo(_ state: State) -> Bool {
+            switch (self, state) {
+            case (.initialized, _):
+                return true
+            case (_, .initialized), (.cancelled, _), (.finished, _):
+                return false
+            case (.resumed, .cancelled), (.suspended, .cancelled), (.resumed, .suspended), (.suspended, .resumed):
+                return true
+            case (.suspended, .suspended), (.resumed, .resumed):
+                return false
+            case (_, .finished):
+                return true
+            }
+        }
+    }
+
+    // MARK: - Initial State
+
+    /// `UUID` providing a unique identifier for the `Request`, used in the `Hashable` and `Equatable` conformances.
+    public let id: UUID
+    /// The serial queue for all internal async actions.
+    public let underlyingQueue: DispatchQueue
+    /// The queue used for all serialization actions. By default it's a serial queue that targets `underlyingQueue`.
+    public let serializationQueue: DispatchQueue
+    /// `EventMonitor` used for event callbacks.
+    public let eventMonitor: EventMonitor?
+    /// The `Request`'s interceptor.
+    public let interceptor: RequestInterceptor?
+    /// The `Request`'s delegate.
+    public private(set) weak var delegate: RequestDelegate?
+
+    // MARK: - Mutable State
+
+    /// Type encapsulating all mutable state that may need to be accessed from anything other than the `underlyingQueue`.
+    struct MutableState {
+        /// State of the `Request`.
+        var state: State = .initialized
+        /// `ProgressHandler` and `DispatchQueue` provided for upload progress callbacks.
+        var uploadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)?
+        /// `ProgressHandler` and `DispatchQueue` provided for download progress callbacks.
+        var downloadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)?
+        /// `RedirectHandler` provided for to handle request redirection.
+        var redirectHandler: RedirectHandler?
+        /// `CachedResponseHandler` provided to handle response caching.
+        var cachedResponseHandler: CachedResponseHandler?
+        /// Queue and closure called when the `Request` is able to create a cURL description of itself.
+        var cURLHandler: (queue: DispatchQueue, handler: (String) -> Void)?
+        /// Queue and closure called when the `Request` creates a `URLRequest`.
+        var urlRequestHandler: (queue: DispatchQueue, handler: (URLRequest) -> Void)?
+        /// Queue and closure called when the `Request` creates a `URLSessionTask`.
+        var urlSessionTaskHandler: (queue: DispatchQueue, handler: (URLSessionTask) -> Void)?
+        /// Response serialization closures that handle response parsing.
+        var responseSerializers: [() -> Void] = []
+        /// Response serialization completion closures executed once all response serializers are complete.
+        var responseSerializerCompletions: [() -> Void] = []
+        /// Whether response serializer processing is finished.
+        var responseSerializerProcessingFinished = false
+        /// `URLCredential` used for authentication challenges.
+        var credential: URLCredential?
+        /// All `URLRequest`s created by Alamofire on behalf of the `Request`.
+        var requests: [URLRequest] = []
+        /// All `URLSessionTask`s created by Alamofire on behalf of the `Request`.
+        var tasks: [URLSessionTask] = []
+        /// All `URLSessionTaskMetrics` values gathered by Alamofire on behalf of the `Request`. Should correspond
+        /// exactly the the `tasks` created.
+        var metrics: [URLSessionTaskMetrics] = []
+        /// Number of times any retriers provided retried the `Request`.
+        var retryCount = 0
+        /// Final `AFError` for the `Request`, whether from various internal Alamofire calls or as a result of a `task`.
+        var error: AFError?
+        /// Whether the instance has had `finish()` called and is running the serializers. Should be replaced with a
+        /// representation in the state machine in the future.
+        var isFinishing = false
+    }
+
+    /// Protected `MutableState` value that provides thread-safe access to state values.
+    @Protected
+    fileprivate var mutableState = MutableState()
+
+    /// `State` of the `Request`.
+    public var state: State { mutableState.state }
+    /// Returns whether `state` is `.initialized`.
+    public var isInitialized: Bool { state == .initialized }
+    /// Returns whether `state is `.resumed`.
+    public var isResumed: Bool { state == .resumed }
+    /// Returns whether `state` is `.suspended`.
+    public var isSuspended: Bool { state == .suspended }
+    /// Returns whether `state` is `.cancelled`.
+    public var isCancelled: Bool { state == .cancelled }
+    /// Returns whether `state` is `.finished`.
+    public var isFinished: Bool { state == .finished }
+
+    // MARK: Progress
+
+    /// Closure type executed when monitoring the upload or download progress of a request.
+    public typealias ProgressHandler = (Progress) -> Void
+
+    /// `Progress` of the upload of the body of the executed `URLRequest`. Reset to `0` if the `Request` is retried.
+    public let uploadProgress = Progress(totalUnitCount: 0)
+    /// `Progress` of the download of any response data. Reset to `0` if the `Request` is retried.
+    public let downloadProgress = Progress(totalUnitCount: 0)
+    /// `ProgressHandler` called when `uploadProgress` is updated, on the provided `DispatchQueue`.
+    private var uploadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)? {
+        get { mutableState.uploadProgressHandler }
+        set { mutableState.uploadProgressHandler = newValue }
+    }
+
+    /// `ProgressHandler` called when `downloadProgress` is updated, on the provided `DispatchQueue`.
+    fileprivate var downloadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)? {
+        get { mutableState.downloadProgressHandler }
+        set { mutableState.downloadProgressHandler = newValue }
+    }
+
+    // MARK: Redirect Handling
+
+    /// `RedirectHandler` set on the instance.
+    public private(set) var redirectHandler: RedirectHandler? {
+        get { mutableState.redirectHandler }
+        set { mutableState.redirectHandler = newValue }
+    }
+
+    // MARK: Cached Response Handling
+
+    /// `CachedResponseHandler` set on the instance.
+    public private(set) var cachedResponseHandler: CachedResponseHandler? {
+        get { mutableState.cachedResponseHandler }
+        set { mutableState.cachedResponseHandler = newValue }
+    }
+
+    // MARK: URLCredential
+
+    /// `URLCredential` used for authentication challenges. Created by calling one of the `authenticate` methods.
+    public private(set) var credential: URLCredential? {
+        get { mutableState.credential }
+        set { mutableState.credential = newValue }
+    }
+
+    // MARK: Validators
+
+    /// `Validator` callback closures that store the validation calls enqueued.
+    @Protected
+    fileprivate var validators: [() -> Void] = []
+
+    // MARK: URLRequests
+
+    /// All `URLRequests` created on behalf of the `Request`, including original and adapted requests.
+    public var requests: [URLRequest] { mutableState.requests }
+    /// First `URLRequest` created on behalf of the `Request`. May not be the first one actually executed.
+    public var firstRequest: URLRequest? { requests.first }
+    /// Last `URLRequest` created on behalf of the `Request`.
+    public var lastRequest: URLRequest? { requests.last }
+    /// Current `URLRequest` created on behalf of the `Request`.
+    public var request: URLRequest? { lastRequest }
+
+    /// `URLRequest`s from all of the `URLSessionTask`s executed on behalf of the `Request`. May be different from
+    /// `requests` due to `URLSession` manipulation.
+    public var performedRequests: [URLRequest] { $mutableState.read { $0.tasks.compactMap { $0.currentRequest } } }
+
+    // MARK: HTTPURLResponse
+
+    /// `HTTPURLResponse` received from the server, if any. If the `Request` was retried, this is the response of the
+    /// last `URLSessionTask`.
+    public var response: HTTPURLResponse? { lastTask?.response as? HTTPURLResponse }
+
+    // MARK: Tasks
+
+    /// All `URLSessionTask`s created on behalf of the `Request`.
+    public var tasks: [URLSessionTask] { mutableState.tasks }
+    /// First `URLSessionTask` created on behalf of the `Request`.
+    public var firstTask: URLSessionTask? { tasks.first }
+    /// Last `URLSessionTask` crated on behalf of the `Request`.
+    public var lastTask: URLSessionTask? { tasks.last }
+    /// Current `URLSessionTask` created on behalf of the `Request`.
+    public var task: URLSessionTask? { lastTask }
+
+    // MARK: Metrics
+
+    /// All `URLSessionTaskMetrics` gathered on behalf of the `Request`. Should correspond to the `tasks` created.
+    public var allMetrics: [URLSessionTaskMetrics] { mutableState.metrics }
+    /// First `URLSessionTaskMetrics` gathered on behalf of the `Request`.
+    public var firstMetrics: URLSessionTaskMetrics? { allMetrics.first }
+    /// Last `URLSessionTaskMetrics` gathered on behalf of the `Request`.
+    public var lastMetrics: URLSessionTaskMetrics? { allMetrics.last }
+    /// Current `URLSessionTaskMetrics` gathered on behalf of the `Request`.
+    public var metrics: URLSessionTaskMetrics? { lastMetrics }
+
+    // MARK: Retry Count
+
+    /// Number of times the `Request` has been retried.
+    public var retryCount: Int { mutableState.retryCount }
+
+    // MARK: Error
+
+    /// `Error` returned from Alamofire internally, from the network request directly, or any validators executed.
+    public fileprivate(set) var error: AFError? {
+        get { mutableState.error }
+        set { mutableState.error = newValue }
+    }
+
+    /// Default initializer for the `Request` superclass.
+    ///
+    /// - Parameters:
+    ///   - id:                 `UUID` used for the `Hashable` and `Equatable` implementations. `UUID()` by default.
+    ///   - underlyingQueue:    `DispatchQueue` on which all internal `Request` work is performed.
+    ///   - serializationQueue: `DispatchQueue` on which all serialization work is performed. By default targets
+    ///                         `underlyingQueue`, but can be passed another queue from a `Session`.
+    ///   - eventMonitor:       `EventMonitor` called for event callbacks from internal `Request` actions.
+    ///   - interceptor:        `RequestInterceptor` used throughout the request lifecycle.
+    ///   - delegate:           `RequestDelegate` that provides an interface to actions not performed by the `Request`.
+    init(id: UUID = UUID(),
+         underlyingQueue: DispatchQueue,
+         serializationQueue: DispatchQueue,
+         eventMonitor: EventMonitor?,
+         interceptor: RequestInterceptor?,
+         delegate: RequestDelegate) {
+        self.id = id
+        self.underlyingQueue = underlyingQueue
+        self.serializationQueue = serializationQueue
+        self.eventMonitor = eventMonitor
+        self.interceptor = interceptor
+        self.delegate = delegate
+    }
+
+    // MARK: - Internal Event API
+
+    // All API must be called from underlyingQueue.
+
+    /// Called when an initial `URLRequest` has been created on behalf of the instance. If a `RequestAdapter` is active,
+    /// the `URLRequest` will be adapted before being issued.
+    ///
+    /// - Parameter request: The `URLRequest` created.
+    func didCreateInitialURLRequest(_ request: URLRequest) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.write { $0.requests.append(request) }
+
+        eventMonitor?.request(self, didCreateInitialURLRequest: request)
+    }
+
+    /// Called when initial `URLRequest` creation has failed, typically through a `URLRequestConvertible`.
+    ///
+    /// - Note: Triggers retry.
+    ///
+    /// - Parameter error: `AFError` thrown from the failed creation.
+    func didFailToCreateURLRequest(with error: AFError) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        self.error = error
+
+        eventMonitor?.request(self, didFailToCreateURLRequestWithError: error)
+
+        callCURLHandlerIfNecessary()
+
+        retryOrFinish(error: error)
+    }
+
+    /// Called when a `RequestAdapter` has successfully adapted a `URLRequest`.
+    ///
+    /// - Parameters:
+    ///   - initialRequest: The `URLRequest` that was adapted.
+    ///   - adaptedRequest: The `URLRequest` returned by the `RequestAdapter`.
+    func didAdaptInitialRequest(_ initialRequest: URLRequest, to adaptedRequest: URLRequest) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.write { $0.requests.append(adaptedRequest) }
+
+        eventMonitor?.request(self, didAdaptInitialRequest: initialRequest, to: adaptedRequest)
+    }
+
+    /// Called when a `RequestAdapter` fails to adapt a `URLRequest`.
+    ///
+    /// - Note: Triggers retry.
+    ///
+    /// - Parameters:
+    ///   - request: The `URLRequest` the adapter was called with.
+    ///   - error:   The `AFError` returned by the `RequestAdapter`.
+    func didFailToAdaptURLRequest(_ request: URLRequest, withError error: AFError) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        self.error = error
+
+        eventMonitor?.request(self, didFailToAdaptURLRequest: request, withError: error)
+
+        callCURLHandlerIfNecessary()
+
+        retryOrFinish(error: error)
+    }
+
+    /// Final `URLRequest` has been created for the instance.
+    ///
+    /// - Parameter request: The `URLRequest` created.
+    func didCreateURLRequest(_ request: URLRequest) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.read { state in
+            state.urlRequestHandler?.queue.async { state.urlRequestHandler?.handler(request) }
+        }
+
+        eventMonitor?.request(self, didCreateURLRequest: request)
+
+        callCURLHandlerIfNecessary()
+    }
+
+    /// Asynchronously calls any stored `cURLHandler` and then removes it from `mutableState`.
+    private func callCURLHandlerIfNecessary() {
+        $mutableState.write { mutableState in
+            guard let cURLHandler = mutableState.cURLHandler else { return }
+
+            cURLHandler.queue.async { cURLHandler.handler(self.cURLDescription()) }
+
+            mutableState.cURLHandler = nil
+        }
+    }
+
+    /// Called when a `URLSessionTask` is created on behalf of the instance.
+    ///
+    /// - Parameter task: The `URLSessionTask` created.
+    func didCreateTask(_ task: URLSessionTask) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.write { state in
+            state.tasks.append(task)
+
+            guard let urlSessionTaskHandler = state.urlSessionTaskHandler else { return }
+
+            urlSessionTaskHandler.queue.async { urlSessionTaskHandler.handler(task) }
+        }
+
+        eventMonitor?.request(self, didCreateTask: task)
+    }
+
+    /// Called when resumption is completed.
+    func didResume() {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        eventMonitor?.requestDidResume(self)
+    }
+
+    /// Called when a `URLSessionTask` is resumed on behalf of the instance.
+    ///
+    /// - Parameter task: The `URLSessionTask` resumed.
+    func didResumeTask(_ task: URLSessionTask) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        eventMonitor?.request(self, didResumeTask: task)
+    }
+
+    /// Called when suspension is completed.
+    func didSuspend() {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        eventMonitor?.requestDidSuspend(self)
+    }
+
+    /// Called when a `URLSessionTask` is suspended on behalf of the instance.
+    ///
+    /// - Parameter task: The `URLSessionTask` suspended.
+    func didSuspendTask(_ task: URLSessionTask) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        eventMonitor?.request(self, didSuspendTask: task)
+    }
+
+    /// Called when cancellation is completed, sets `error` to `AFError.explicitlyCancelled`.
+    func didCancel() {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        error = error ?? AFError.explicitlyCancelled
+
+        eventMonitor?.requestDidCancel(self)
+    }
+
+    /// Called when a `URLSessionTask` is cancelled on behalf of the instance.
+    ///
+    /// - Parameter task: The `URLSessionTask` cancelled.
+    func didCancelTask(_ task: URLSessionTask) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        eventMonitor?.request(self, didCancelTask: task)
+    }
+
+    /// Called when a `URLSessionTaskMetrics` value is gathered on behalf of the instance.
+    ///
+    /// - Parameter metrics: The `URLSessionTaskMetrics` gathered.
+    func didGatherMetrics(_ metrics: URLSessionTaskMetrics) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.write { $0.metrics.append(metrics) }
+
+        eventMonitor?.request(self, didGatherMetrics: metrics)
+    }
+
+    /// Called when a `URLSessionTask` fails before it is finished, typically during certificate pinning.
+    ///
+    /// - Parameters:
+    ///   - task:  The `URLSessionTask` which failed.
+    ///   - error: The early failure `AFError`.
+    func didFailTask(_ task: URLSessionTask, earlyWithError error: AFError) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        self.error = error
+
+        // Task will still complete, so didCompleteTask(_:with:) will handle retry.
+        eventMonitor?.request(self, didFailTask: task, earlyWithError: error)
+    }
+
+    /// Called when a `URLSessionTask` completes. All tasks will eventually call this method.
+    ///
+    /// - Note: Response validation is synchronously triggered in this step.
+    ///
+    /// - Parameters:
+    ///   - task:  The `URLSessionTask` which completed.
+    ///   - error: The `AFError` `task` may have completed with. If `error` has already been set on the instance, this
+    ///            value is ignored.
+    func didCompleteTask(_ task: URLSessionTask, with error: AFError?) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        self.error = self.error ?? error
+
+        validators.forEach { $0() }
+
+        eventMonitor?.request(self, didCompleteTask: task, with: error)
+
+        retryOrFinish(error: self.error)
+    }
+
+    /// Called when the `RequestDelegate` is going to retry this `Request`. Calls `reset()`.
+    func prepareForRetry() {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        $mutableState.write { $0.retryCount += 1 }
+
+        reset()
+
+        eventMonitor?.requestIsRetrying(self)
+    }
+
+    /// Called to determine whether retry will be triggered for the particular error, or whether the instance should
+    /// call `finish()`.
+    ///
+    /// - Parameter error: The possible `AFError` which may trigger retry.
+    func retryOrFinish(error: AFError?) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        guard let error = error, let delegate = delegate else { finish(); return }
+
+        delegate.retryResult(for: self, dueTo: error) { retryResult in
+            switch retryResult {
+            case .doNotRetry:
+                self.finish()
+            case let .doNotRetryWithError(retryError):
+                self.finish(error: retryError.asAFError(orFailWith: "Received retryError was not already AFError"))
+            case .retry, .retryWithDelay:
+                delegate.retryRequest(self, withDelay: retryResult.delay)
+            }
+        }
+    }
+
+    /// Finishes this `Request` and starts the response serializers.
+    ///
+    /// - Parameter error: The possible `Error` with which the instance will finish.
+    func finish(error: AFError? = nil) {
+        dispatchPrecondition(condition: .onQueue(underlyingQueue))
+
+        guard !mutableState.isFinishing else { return }
+
+        mutableState.isFinishing = true
+
+        if let error = error { self.error = error }
+
+        // Start response handlers
+        processNextResponseSerializer()
+
+        eventMonitor?.requestDidFinish(self)
+    }
+
+    /// Appends the response serialization closure to the instance.
+    ///
+    ///  - Note: This method will also `resume` the instance if `delegate.startImmediately` returns `true`.
+    ///
+    /// - Parameter closure: The closure containing the response serialization call.
+    func appendResponseSerializer(_ closure: @escaping () -> Void) {
+        $mutableState.write { mutableState in
+            mutableState.responseSerializers.append(closure)
+
+            if mutableState.state == .finished {
+                mutableState.state = .resumed
+            }
+
+            if mutableState.responseSerializerProcessingFinished {
+                underlyingQueue.async { self.processNextResponseSerializer() }
+            }
+
+            if mutableState.state.canTransitionTo(.resumed) {
+                underlyingQueue.async { if self.delegate?.startImmediately == true { self.resume() } }
+            }
+        }
+    }
+
+    /// Returns the next response serializer closure to execute if there's one left.
+    ///
+    /// - Returns: The next response serialization closure, if there is one.
+    func nextResponseSerializer() -> (() -> Void)? {
+        var responseSerializer: (() -> Void)?
+
+        $mutableState.write { mutableState in
+            let responseSerializerIndex = mutableState.responseSerializerCompletions.count
+
+            if responseSerializerIndex < mutableState.responseSerializers.count {
+                responseSerializer = mutableState.responseSerializers[responseSerializerIndex]
+            }
+        }
+
+        return responseSerializer
+    }
+
+    /// Processes the next response serializer and calls all completions if response serialization is complete.
+    func processNextResponseSerializer() {
+        guard let responseSerializer = nextResponseSerializer() else {
+            // Execute all response serializer completions and clear them
+            var completions: [() -> Void] = []
+
+            $mutableState.write { mutableState in
+                completions = mutableState.responseSerializerCompletions
+
+                // Clear out all response serializers and response serializer completions in mutable state since the
+                // request is complete. It's important to do this prior to calling the completion closures in case
+                // the completions call back into the request triggering a re-processing of the response serializers.
+                // An example of how this can happen is by calling cancel inside a response completion closure.
+                mutableState.responseSerializers.removeAll()
+                mutableState.responseSerializerCompletions.removeAll()
+
+                if mutableState.state.canTransitionTo(.finished) {
+                    mutableState.state = .finished
+                }
+
+                mutableState.responseSerializerProcessingFinished = true
+                mutableState.isFinishing = false
+            }
+
+            completions.forEach { $0() }
+
+            // Cleanup the request
+            cleanup()
+
+            return
+        }
+
+        serializationQueue.async { responseSerializer() }
+    }
+
+    /// Notifies the `Request` that the response serializer is complete.
+    ///
+    /// - Parameter completion: The completion handler provided with the response serializer, called when all serializers
+    ///                         are complete.
+    func responseSerializerDidComplete(completion: @escaping () -> Void) {
+        $mutableState.write { $0.responseSerializerCompletions.append(completion) }
+        processNextResponseSerializer()
+    }
+
+    /// Resets all task and response serializer related state for retry.
+    func reset() {
+        error = nil
+
+        uploadProgress.totalUnitCount = 0
+        uploadProgress.completedUnitCount = 0
+        downloadProgress.totalUnitCount = 0
+        downloadProgress.completedUnitCount = 0
+
+        $mutableState.write { state in
+            state.isFinishing = false
+            state.responseSerializerCompletions = []
+        }
+    }
+
+    /// Called when updating the upload progress.
+    ///
+    /// - Parameters:
+    ///   - totalBytesSent: Total bytes sent so far.
+    ///   - totalBytesExpectedToSend: Total bytes expected to send.
+    func updateUploadProgress(totalBytesSent: Int64, totalBytesExpectedToSend: Int64) {
+        uploadProgress.totalUnitCount = totalBytesExpectedToSend
+        uploadProgress.completedUnitCount = totalBytesSent
+
+        uploadProgressHandler?.queue.async { self.uploadProgressHandler?.handler(self.uploadProgress) }
+    }
+
+    /// Perform a closure on the current `state` while locked.
+    ///
+    /// - Parameter perform: The closure to perform.
+    func withState(perform: (State) -> Void) {
+        $mutableState.withState(perform: perform)
+    }
+
+    // MARK: Task Creation
+
+    /// Called when creating a `URLSessionTask` for this `Request`. Subclasses must override.
+    ///
+    /// - Parameters:
+    ///   - request: `URLRequest` to use to create the `URLSessionTask`.
+    ///   - session: `URLSession` which creates the `URLSessionTask`.
+    ///
+    /// - Returns:   The `URLSessionTask` created.
+    func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
+        fatalError("Subclasses must override.")
+    }
+
+    // MARK: - Public API
+
+    // These APIs are callable from any queue.
+
+    // MARK: State
+
+    /// Cancels the instance. Once cancelled, a `Request` can no longer be resumed or suspended.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    public func cancel() -> Self {
+        $mutableState.write { mutableState in
+            guard mutableState.state.canTransitionTo(.cancelled) else { return }
+
+            mutableState.state = .cancelled
+
+            underlyingQueue.async { self.didCancel() }
+
+            guard let task = mutableState.tasks.last, task.state != .completed else {
+                underlyingQueue.async { self.finish() }
+                return
+            }
+
+            // Resume to ensure metrics are gathered.
+            task.resume()
+            task.cancel()
+            underlyingQueue.async { self.didCancelTask(task) }
+        }
+
+        return self
+    }
+
+    /// Suspends the instance.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    public func suspend() -> Self {
+        $mutableState.write { mutableState in
+            guard mutableState.state.canTransitionTo(.suspended) else { return }
+
+            mutableState.state = .suspended
+
+            underlyingQueue.async { self.didSuspend() }
+
+            guard let task = mutableState.tasks.last, task.state != .completed else { return }
+
+            task.suspend()
+            underlyingQueue.async { self.didSuspendTask(task) }
+        }
+
+        return self
+    }
+
+    /// Resumes the instance.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    public func resume() -> Self {
+        $mutableState.write { mutableState in
+            guard mutableState.state.canTransitionTo(.resumed) else { return }
+
+            mutableState.state = .resumed
+
+            underlyingQueue.async { self.didResume() }
+
+            guard let task = mutableState.tasks.last, task.state != .completed else { return }
+
+            task.resume()
+            underlyingQueue.async { self.didResumeTask(task) }
+        }
+
+        return self
+    }
+
+    // MARK: - Closure API
+
+    /// Associates a credential using the provided values with the instance.
+    ///
+    /// - Parameters:
+    ///   - username:    The username.
+    ///   - password:    The password.
+    ///   - persistence: The `URLCredential.Persistence` for the created `URLCredential`. `.forSession` by default.
+    ///
+    /// - Returns:       The instance.
+    @discardableResult
+    public func authenticate(username: String, password: String, persistence: URLCredential.Persistence = .forSession) -> Self {
+        let credential = URLCredential(user: username, password: password, persistence: persistence)
+
+        return authenticate(with: credential)
+    }
+
+    /// Associates the provided credential with the instance.
+    ///
+    /// - Parameter credential: The `URLCredential`.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func authenticate(with credential: URLCredential) -> Self {
+        mutableState.credential = credential
+
+        return self
+    }
+
+    /// Sets a closure to be called periodically during the lifecycle of the instance as data is read from the server.
+    ///
+    /// - Note: Only the last closure provided is used.
+    ///
+    /// - Parameters:
+    ///   - queue:   The `DispatchQueue` to execute the closure on. `.main` by default.
+    ///   - closure: The closure to be executed periodically as data is read from the server.
+    ///
+    /// - Returns:   The instance.
+    @discardableResult
+    public func downloadProgress(queue: DispatchQueue = .main, closure: @escaping ProgressHandler) -> Self {
+        mutableState.downloadProgressHandler = (handler: closure, queue: queue)
+
+        return self
+    }
+
+    /// Sets a closure to be called periodically during the lifecycle of the instance as data is sent to the server.
+    ///
+    /// - Note: Only the last closure provided is used.
+    ///
+    /// - Parameters:
+    ///   - queue:   The `DispatchQueue` to execute the closure on. `.main` by default.
+    ///   - closure: The closure to be executed periodically as data is sent to the server.
+    ///
+    /// - Returns:   The instance.
+    @discardableResult
+    public func uploadProgress(queue: DispatchQueue = .main, closure: @escaping ProgressHandler) -> Self {
+        mutableState.uploadProgressHandler = (handler: closure, queue: queue)
+
+        return self
+    }
+
+    // MARK: Redirects
+
+    /// Sets the redirect handler for the instance which will be used if a redirect response is encountered.
+    ///
+    /// - Note: Attempting to set the redirect handler more than once is a logic error and will crash.
+    ///
+    /// - Parameter handler: The `RedirectHandler`.
+    ///
+    /// - Returns:           The instance.
+    @discardableResult
+    public func redirect(using handler: RedirectHandler) -> Self {
+        $mutableState.write { mutableState in
+            precondition(mutableState.redirectHandler == nil, "Redirect handler has already been set.")
+            mutableState.redirectHandler = handler
+        }
+
+        return self
+    }
+
+    // MARK: Cached Responses
+
+    /// Sets the cached response handler for the `Request` which will be used when attempting to cache a response.
+    ///
+    /// - Note: Attempting to set the cache handler more than once is a logic error and will crash.
+    ///
+    /// - Parameter handler: The `CachedResponseHandler`.
+    ///
+    /// - Returns:           The instance.
+    @discardableResult
+    public func cacheResponse(using handler: CachedResponseHandler) -> Self {
+        $mutableState.write { mutableState in
+            precondition(mutableState.cachedResponseHandler == nil, "Cached response handler has already been set.")
+            mutableState.cachedResponseHandler = handler
+        }
+
+        return self
+    }
+
+    // MARK: - Lifetime APIs
+
+    /// Sets a handler to be called when the cURL description of the request is available.
+    ///
+    /// - Note: When waiting for a `Request`'s `URLRequest` to be created, only the last `handler` will be called.
+    ///
+    /// - Parameters:
+    ///   - queue:   `DispatchQueue` on which `handler` will be called.
+    ///   - handler: Closure to be called when the cURL description is available.
+    ///
+    /// - Returns:           The instance.
+    @discardableResult
+    public func cURLDescription(on queue: DispatchQueue, calling handler: @escaping (String) -> Void) -> Self {
+        $mutableState.write { mutableState in
+            if mutableState.requests.last != nil {
+                queue.async { handler(self.cURLDescription()) }
+            } else {
+                mutableState.cURLHandler = (queue, handler)
+            }
+        }
+
+        return self
+    }
+
+    /// Sets a handler to be called when the cURL description of the request is available.
+    ///
+    /// - Note: When waiting for a `Request`'s `URLRequest` to be created, only the last `handler` will be called.
+    ///
+    /// - Parameter handler: Closure to be called when the cURL description is available. Called on the instance's
+    ///                      `underlyingQueue` by default.
+    ///
+    /// - Returns:           The instance.
+    @discardableResult
+    public func cURLDescription(calling handler: @escaping (String) -> Void) -> Self {
+        $mutableState.write { mutableState in
+            if mutableState.requests.last != nil {
+                underlyingQueue.async { handler(self.cURLDescription()) }
+            } else {
+                mutableState.cURLHandler = (underlyingQueue, handler)
+            }
+        }
+
+        return self
+    }
+
+    /// Sets a closure to called whenever Alamofire creates a `URLRequest` for this instance.
+    ///
+    /// - Note: This closure will be called multiple times if the instance adapts incoming `URLRequest`s or is retried.
+    ///
+    /// - Parameters:
+    ///   - queue:   `DispatchQueue` on which `handler` will be called. `.main` by default.
+    ///   - handler: Closure to be called when a `URLRequest` is available.
+    ///
+    /// - Returns:   The instance.
+    @discardableResult
+    public func onURLRequestCreation(on queue: DispatchQueue = .main, perform handler: @escaping (URLRequest) -> Void) -> Self {
+        $mutableState.write { state in
+            if let request = state.requests.last {
+                queue.async { handler(request) }
+            }
+
+            state.urlRequestHandler = (queue, handler)
+        }
+
+        return self
+    }
+
+    /// Sets a closure to be called whenever the instance creates a `URLSessionTask`.
+    ///
+    /// - Note: This API should only be used to provide `URLSessionTask`s to existing API, like `NSFileProvider`. It
+    ///         **SHOULD NOT** be used to interact with tasks directly, as that may be break Alamofire features.
+    ///         Additionally, this closure may be called multiple times if the instance is retried.
+    ///
+    /// - Parameters:
+    ///   - queue:   `DispatchQueue` on which `handler` will be called. `.main` by default.
+    ///   - handler: Closure to be called when the `URLSessionTask` is available.
+    ///
+    /// - Returns:   The instance.
+    @discardableResult
+    public func onURLSessionTaskCreation(on queue: DispatchQueue = .main, perform handler: @escaping (URLSessionTask) -> Void) -> Self {
+        $mutableState.write { state in
+            if let task = state.tasks.last {
+                queue.async { handler(task) }
+            }
+
+            state.urlSessionTaskHandler = (queue, handler)
+        }
+
+        return self
+    }
+
+    // MARK: Cleanup
+
+    /// Final cleanup step executed when the instance finishes response serialization.
+    func cleanup() {
+        delegate?.cleanup(after: self)
+        // No-op: override in subclass
+    }
+}
+
+// MARK: - Protocol Conformances
+
+extension Request: Equatable {
+    public static func ==(lhs: Request, rhs: Request) -> Bool {
+        lhs.id == rhs.id
+    }
+}
+
+extension Request: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+    }
+}
+
+extension Request: CustomStringConvertible {
+    /// A textual representation of this instance, including the `HTTPMethod` and `URL` if the `URLRequest` has been
+    /// created, as well as the response status code, if a response has been received.
+    public var description: String {
+        guard let request = performedRequests.last ?? lastRequest,
+              let url = request.url,
+              let method = request.httpMethod else { return "No request created yet." }
+
+        let requestDescription = "\(method) \(url.absoluteString)"
+
+        return response.map { "\(requestDescription) (\($0.statusCode))" } ?? requestDescription
+    }
+}
+
+extension Request {
+    /// cURL representation of the instance.
+    ///
+    /// - Returns: The cURL equivalent of the instance.
+    public func cURLDescription() -> String {
+        guard
+            let request = lastRequest,
+            let url = request.url,
+            let host = url.host,
+            let method = request.httpMethod else { return "$ curl command could not be created" }
+
+        var components = ["$ curl -v"]
+
+        components.append("-X \(method)")
+
+        if let credentialStorage = delegate?.sessionConfiguration.urlCredentialStorage {
+            let protectionSpace = URLProtectionSpace(host: host,
+                                                     port: url.port ?? 0,
+                                                     protocol: url.scheme,
+                                                     realm: host,
+                                                     authenticationMethod: NSURLAuthenticationMethodHTTPBasic)
+
+            if let credentials = credentialStorage.credentials(for: protectionSpace)?.values {
+                for credential in credentials {
+                    guard let user = credential.user, let password = credential.password else { continue }
+                    components.append("-u \(user):\(password)")
+                }
+            } else {
+                if let credential = credential, let user = credential.user, let password = credential.password {
+                    components.append("-u \(user):\(password)")
+                }
+            }
+        }
+
+        if let configuration = delegate?.sessionConfiguration, configuration.httpShouldSetCookies {
+            if
+                let cookieStorage = configuration.httpCookieStorage,
+                let cookies = cookieStorage.cookies(for: url), !cookies.isEmpty {
+                let allCookies = cookies.map { "\($0.name)=\($0.value)" }.joined(separator: ";")
+
+                components.append("-b \"\(allCookies)\"")
+            }
+        }
+
+        var headers = HTTPHeaders()
+
+        if let sessionHeaders = delegate?.sessionConfiguration.headers {
+            for header in sessionHeaders where header.name != "Cookie" {
+                headers[header.name] = header.value
+            }
+        }
+
+        for header in request.headers where header.name != "Cookie" {
+            headers[header.name] = header.value
+        }
+
+        for header in headers {
+            let escapedValue = header.value.replacingOccurrences(of: "\"", with: "\\\"")
+            components.append("-H \"\(header.name): \(escapedValue)\"")
+        }
+
+        if let httpBodyData = request.httpBody {
+            let httpBody = String(decoding: httpBodyData, as: UTF8.self)
+            var escapedBody = httpBody.replacingOccurrences(of: "\\\"", with: "\\\\\"")
+            escapedBody = escapedBody.replacingOccurrences(of: "\"", with: "\\\"")
+
+            components.append("-d \"\(escapedBody)\"")
+        }
+
+        components.append("\"\(url.absoluteString)\"")
+
+        return components.joined(separator: " \\\n\t")
+    }
+}
+
+/// Protocol abstraction for `Request`'s communication back to the `SessionDelegate`.
+public protocol RequestDelegate: AnyObject {
+    /// `URLSessionConfiguration` used to create the underlying `URLSessionTask`s.
+    var sessionConfiguration: URLSessionConfiguration { get }
+
+    /// Determines whether the `Request` should automatically call `resume()` when adding the first response handler.
+    var startImmediately: Bool { get }
+
+    /// Notifies the delegate the `Request` has reached a point where it needs cleanup.
+    ///
+    /// - Parameter request: The `Request` to cleanup after.
+    func cleanup(after request: Request)
+
+    /// Asynchronously ask the delegate whether a `Request` will be retried.
+    ///
+    /// - Parameters:
+    ///   - request:    `Request` which failed.
+    ///   - error:      `Error` which produced the failure.
+    ///   - completion: Closure taking the `RetryResult` for evaluation.
+    func retryResult(for request: Request, dueTo error: AFError, completion: @escaping (RetryResult) -> Void)
+
+    /// Asynchronously retry the `Request`.
+    ///
+    /// - Parameters:
+    ///   - request:   `Request` which will be retried.
+    ///   - timeDelay: `TimeInterval` after which the retry will be triggered.
+    func retryRequest(_ request: Request, withDelay timeDelay: TimeInterval?)
+}
+
+// MARK: - Subclasses
+
+// MARK: - DataRequest
+
+/// `Request` subclass which handles in-memory `Data` download using `URLSessionDataTask`.
+public class DataRequest: Request {
+    /// `URLRequestConvertible` value used to create `URLRequest`s for this instance.
+    public let convertible: URLRequestConvertible
+    /// `Data` read from the server so far.
+    public var data: Data? { mutableData }
+
+    /// Protected storage for the `Data` read by the instance.
+    @Protected
+    private var mutableData: Data? = nil
+
+    /// Creates a `DataRequest` using the provided parameters.
+    ///
+    /// - Parameters:
+    ///   - id:                 `UUID` used for the `Hashable` and `Equatable` implementations. `UUID()` by default.
+    ///   - convertible:        `URLRequestConvertible` value used to create `URLRequest`s for this instance.
+    ///   - underlyingQueue:    `DispatchQueue` on which all internal `Request` work is performed.
+    ///   - serializationQueue: `DispatchQueue` on which all serialization work is performed. By default targets
+    ///                         `underlyingQueue`, but can be passed another queue from a `Session`.
+    ///   - eventMonitor:       `EventMonitor` called for event callbacks from internal `Request` actions.
+    ///   - interceptor:        `RequestInterceptor` used throughout the request lifecycle.
+    ///   - delegate:           `RequestDelegate` that provides an interface to actions not performed by the `Request`.
+    init(id: UUID = UUID(),
+         convertible: URLRequestConvertible,
+         underlyingQueue: DispatchQueue,
+         serializationQueue: DispatchQueue,
+         eventMonitor: EventMonitor?,
+         interceptor: RequestInterceptor?,
+         delegate: RequestDelegate) {
+        self.convertible = convertible
+
+        super.init(id: id,
+                   underlyingQueue: underlyingQueue,
+                   serializationQueue: serializationQueue,
+                   eventMonitor: eventMonitor,
+                   interceptor: interceptor,
+                   delegate: delegate)
+    }
+
+    override func reset() {
+        super.reset()
+
+        mutableData = nil
+    }
+
+    /// Called when `Data` is received by this instance.
+    ///
+    /// - Note: Also calls `updateDownloadProgress`.
+    ///
+    /// - Parameter data: The `Data` received.
+    func didReceive(data: Data) {
+        if self.data == nil {
+            mutableData = data
+        } else {
+            $mutableData.write { $0?.append(data) }
+        }
+
+        updateDownloadProgress()
+    }
+
+    override func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
+        let copiedRequest = request
+        return session.dataTask(with: copiedRequest)
+    }
+
+    /// Called to updated the `downloadProgress` of the instance.
+    func updateDownloadProgress() {
+        let totalBytesReceived = Int64(data?.count ?? 0)
+        let totalBytesExpected = task?.response?.expectedContentLength ?? NSURLSessionTransferSizeUnknown
+
+        downloadProgress.totalUnitCount = totalBytesExpected
+        downloadProgress.completedUnitCount = totalBytesReceived
+
+        downloadProgressHandler?.queue.async { self.downloadProgressHandler?.handler(self.downloadProgress) }
+    }
+
+    /// Validates the request, using the specified closure.
+    ///
+    /// - Note: If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Parameter validation: `Validation` closure used to validate the response.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func validate(_ validation: @escaping Validation) -> Self {
+        let validator: () -> Void = { [unowned self] in
+            guard self.error == nil, let response = self.response else { return }
+
+            let result = validation(self.request, response, self.data)
+
+            if case let .failure(error) = result { self.error = error.asAFError(or: .responseValidationFailed(reason: .customValidationFailed(error: error))) }
+
+            self.eventMonitor?.request(self,
+                                       didValidateRequest: self.request,
+                                       response: response,
+                                       data: self.data,
+                                       withResult: result)
+        }
+
+        $validators.write { $0.append(validator) }
+
+        return self
+    }
+}
+
+// MARK: - DataStreamRequest
+
+/// `Request` subclass which streams HTTP response `Data` through a `Handler` closure.
+public final class DataStreamRequest: Request {
+    /// Closure type handling `DataStreamRequest.Stream` values.
+    public typealias Handler<Success, Failure: Error> = (Stream<Success, Failure>) throws -> Void
+
+    /// Type encapsulating an `Event` as it flows through the stream, as well as a `CancellationToken` which can be used
+    /// to stop the stream at any time.
+    public struct Stream<Success, Failure: Error> {
+        /// Latest `Event` from the stream.
+        public let event: Event<Success, Failure>
+        /// Token used to cancel the stream.
+        public let token: CancellationToken
+
+        /// Cancel the ongoing stream by canceling the underlying `DataStreamRequest`.
+        public func cancel() {
+            token.cancel()
+        }
+    }
+
+    /// Type representing an event flowing through the stream. Contains either the `Result` of processing streamed
+    /// `Data` or the completion of the stream.
+    public enum Event<Success, Failure: Error> {
+        /// Output produced every time the instance receives additional `Data`. The associated value contains the
+        /// `Result` of processing the incoming `Data`.
+        case stream(Result<Success, Failure>)
+        /// Output produced when the instance has completed, whether due to stream end, cancellation, or an error.
+        /// Associated `Completion` value contains the final state.
+        case complete(Completion)
+    }
+
+    /// Value containing the state of a `DataStreamRequest` when the stream was completed.
+    public struct Completion {
+        /// Last `URLRequest` issued by the instance.
+        public let request: URLRequest?
+        /// Last `HTTPURLResponse` received by the instance.
+        public let response: HTTPURLResponse?
+        /// Last `URLSessionTaskMetrics` produced for the instance.
+        public let metrics: URLSessionTaskMetrics?
+        /// `AFError` produced for the instance, if any.
+        public let error: AFError?
+    }
+
+    /// Type used to cancel an ongoing stream.
+    public struct CancellationToken {
+        weak var request: DataStreamRequest?
+
+        init(_ request: DataStreamRequest) {
+            self.request = request
+        }
+
+        /// Cancel the ongoing stream by canceling the underlying `DataStreamRequest`.
+        public func cancel() {
+            request?.cancel()
+        }
+    }
+
+    /// `URLRequestConvertible` value used to create `URLRequest`s for this instance.
+    public let convertible: URLRequestConvertible
+    /// Whether or not the instance will be cancelled if stream parsing encounters an error.
+    public let automaticallyCancelOnStreamError: Bool
+
+    /// Internal mutable state specific to this type.
+    struct StreamMutableState {
+        /// `OutputStream` bound to the `InputStream` produced by `asInputStream`, if it has been called.
+        var outputStream: OutputStream?
+        /// Stream closures called as `Data` is received.
+        var streams: [(_ data: Data) -> Void] = []
+        /// Number of currently executing streams. Used to ensure completions are only fired after all streams are
+        /// enqueued.
+        var numberOfExecutingStreams = 0
+        /// Completion calls enqueued while streams are still executing.
+        var enqueuedCompletionEvents: [() -> Void] = []
+    }
+
+    @Protected
+    var streamMutableState = StreamMutableState()
+
+    /// Creates a `DataStreamRequest` using the provided parameters.
+    ///
+    /// - Parameters:
+    ///   - id:                               `UUID` used for the `Hashable` and `Equatable` implementations. `UUID()`
+    ///                                        by default.
+    ///   - convertible:                      `URLRequestConvertible` value used to create `URLRequest`s for this
+    ///                                        instance.
+    ///   - automaticallyCancelOnStreamError: `Bool` indicating whether the instance will be cancelled when an `Error`
+    ///                                       is thrown while serializing stream `Data`.
+    ///   - underlyingQueue:                  `DispatchQueue` on which all internal `Request` work is performed.
+    ///   - serializationQueue:               `DispatchQueue` on which all serialization work is performed. By default
+    ///                                       targets
+    ///                                       `underlyingQueue`, but can be passed another queue from a `Session`.
+    ///   - eventMonitor:                     `EventMonitor` called for event callbacks from internal `Request` actions.
+    ///   - interceptor:                      `RequestInterceptor` used throughout the request lifecycle.
+    ///   - delegate:                         `RequestDelegate` that provides an interface to actions not performed by
+    ///                                       the `Request`.
+    init(id: UUID = UUID(),
+         convertible: URLRequestConvertible,
+         automaticallyCancelOnStreamError: Bool,
+         underlyingQueue: DispatchQueue,
+         serializationQueue: DispatchQueue,
+         eventMonitor: EventMonitor?,
+         interceptor: RequestInterceptor?,
+         delegate: RequestDelegate) {
+        self.convertible = convertible
+        self.automaticallyCancelOnStreamError = automaticallyCancelOnStreamError
+
+        super.init(id: id,
+                   underlyingQueue: underlyingQueue,
+                   serializationQueue: serializationQueue,
+                   eventMonitor: eventMonitor,
+                   interceptor: interceptor,
+                   delegate: delegate)
+    }
+
+    override func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
+        let copiedRequest = request
+        return session.dataTask(with: copiedRequest)
+    }
+
+    override func finish(error: AFError? = nil) {
+        $streamMutableState.write { state in
+            state.outputStream?.close()
+        }
+
+        super.finish(error: error)
+    }
+
+    func didReceive(data: Data) {
+        $streamMutableState.write { state in
+            #if !(os(Linux) || os(Windows))
+            if let stream = state.outputStream {
+                underlyingQueue.async {
+                    var bytes = Array(data)
+                    stream.write(&bytes, maxLength: bytes.count)
+                }
+            }
+            #endif
+            state.numberOfExecutingStreams += state.streams.count
+            let localState = state
+            underlyingQueue.async { localState.streams.forEach { $0(data) } }
+        }
+    }
+
+    /// Validates the `URLRequest` and `HTTPURLResponse` received for the instance using the provided `Validation` closure.
+    ///
+    /// - Parameter validation: `Validation` closure used to validate the request and response.
+    ///
+    /// - Returns:              The `DataStreamRequest`.
+    @discardableResult
+    public func validate(_ validation: @escaping Validation) -> Self {
+        let validator: () -> Void = { [unowned self] in
+            guard self.error == nil, let response = self.response else { return }
+
+            let result = validation(self.request, response)
+
+            if case let .failure(error) = result {
+                self.error = error.asAFError(or: .responseValidationFailed(reason: .customValidationFailed(error: error)))
+            }
+
+            self.eventMonitor?.request(self,
+                                       didValidateRequest: self.request,
+                                       response: response,
+                                       withResult: result)
+        }
+
+        $validators.write { $0.append(validator) }
+
+        return self
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// Produces an `InputStream` that receives the `Data` received by the instance.
+    ///
+    /// - Note: The `InputStream` produced by this method must have `open()` called before being able to read `Data`.
+    ///         Additionally, this method will automatically call `resume()` on the instance, regardless of whether or
+    ///         not the creating session has `startRequestsImmediately` set to `true`.
+    ///
+    /// - Parameter bufferSize: Size, in bytes, of the buffer between the `OutputStream` and `InputStream`.
+    ///
+    /// - Returns:              The `InputStream` bound to the internal `OutboundStream`.
+    public func asInputStream(bufferSize: Int = 1024) -> InputStream? {
+        defer { resume() }
+
+        var inputStream: InputStream?
+        $streamMutableState.write { state in
+            Foundation.Stream.getBoundStreams(withBufferSize: bufferSize,
+                                              inputStream: &inputStream,
+                                              outputStream: &state.outputStream)
+            state.outputStream?.open()
+        }
+
+        return inputStream
+    }
+    #endif
+
+    func capturingError(from closure: () throws -> Void) {
+        do {
+            try closure()
+        } catch {
+            self.error = error.asAFError(or: .responseSerializationFailed(reason: .customSerializationFailed(error: error)))
+            cancel()
+        }
+    }
+
+    func appendStreamCompletion<Success, Failure>(on queue: DispatchQueue,
+                                                  stream: @escaping Handler<Success, Failure>) {
+        appendResponseSerializer {
+            self.underlyingQueue.async {
+                self.responseSerializerDidComplete {
+                    self.$streamMutableState.write { state in
+                        guard state.numberOfExecutingStreams == 0 else {
+                            state.enqueuedCompletionEvents.append {
+                                self.enqueueCompletion(on: queue, stream: stream)
+                            }
+
+                            return
+                        }
+
+                        self.enqueueCompletion(on: queue, stream: stream)
+                    }
+                }
+            }
+        }
+    }
+
+    func enqueueCompletion<Success, Failure>(on queue: DispatchQueue,
+                                             stream: @escaping Handler<Success, Failure>) {
+        queue.async {
+            do {
+                let completion = Completion(request: self.request,
+                                            response: self.response,
+                                            metrics: self.metrics,
+                                            error: self.error)
+                try stream(.init(event: .complete(completion), token: .init(self)))
+            } catch {
+                // Ignore error, as errors on Completion can't be handled anyway.
+            }
+        }
+    }
+}
+
+extension DataStreamRequest.Stream {
+    /// Incoming `Result` values from `Event.stream`.
+    public var result: Result<Success, Failure>? {
+        guard case let .stream(result) = event else { return nil }
+
+        return result
+    }
+
+    /// `Success` value of the instance, if any.
+    public var value: Success? {
+        guard case let .success(value) = result else { return nil }
+
+        return value
+    }
+
+    /// `Failure` value of the instance, if any.
+    public var error: Failure? {
+        guard case let .failure(error) = result else { return nil }
+
+        return error
+    }
+
+    /// `Completion` value of the instance, if any.
+    public var completion: DataStreamRequest.Completion? {
+        guard case let .complete(completion) = event else { return nil }
+
+        return completion
+    }
+}
+
+// MARK: - DownloadRequest
+
+/// `Request` subclass which downloads `Data` to a file on disk using `URLSessionDownloadTask`.
+public class DownloadRequest: Request {
+    /// A set of options to be executed prior to moving a downloaded file from the temporary `URL` to the destination
+    /// `URL`.
+    public struct Options: OptionSet {
+        /// Specifies that intermediate directories for the destination URL should be created.
+        public static let createIntermediateDirectories = Options(rawValue: 1 << 0)
+        /// Specifies that any previous file at the destination `URL` should be removed.
+        public static let removePreviousFile = Options(rawValue: 1 << 1)
+
+        public let rawValue: Int
+
+        public init(rawValue: Int) {
+            self.rawValue = rawValue
+        }
+    }
+
+    // MARK: Destination
+
+    /// A closure executed once a `DownloadRequest` has successfully completed in order to determine where to move the
+    /// temporary file written to during the download process. The closure takes two arguments: the temporary file URL
+    /// and the `HTTPURLResponse`, and returns two values: the file URL where the temporary file should be moved and
+    /// the options defining how the file should be moved.
+    ///
+    /// - Note: Downloads from a local `file://` `URL`s do not use the `Destination` closure, as those downloads do not
+    ///         return an `HTTPURLResponse`. Instead the file is merely moved within the temporary directory.
+    public typealias Destination = (_ temporaryURL: URL,
+                                    _ response: HTTPURLResponse) -> (destinationURL: URL, options: Options)
+
+    /// Creates a download file destination closure which uses the default file manager to move the temporary file to a
+    /// file URL in the first available directory with the specified search path directory and search path domain mask.
+    ///
+    /// - Parameters:
+    ///   - directory: The search path directory. `.documentDirectory` by default.
+    ///   - domain:    The search path domain mask. `.userDomainMask` by default.
+    ///   - options:   `DownloadRequest.Options` used when moving the downloaded file to its destination. None by
+    ///                default.
+    /// - Returns: The `Destination` closure.
+    public class func suggestedDownloadDestination(for directory: FileManager.SearchPathDirectory = .documentDirectory,
+                                                   in domain: FileManager.SearchPathDomainMask = .userDomainMask,
+                                                   options: Options = []) -> Destination {
+        { temporaryURL, response in
+            let directoryURLs = FileManager.default.urls(for: directory, in: domain)
+            let url = directoryURLs.first?.appendingPathComponent(response.suggestedFilename!) ?? temporaryURL
+
+            return (url, options)
+        }
+    }
+
+    /// Default `Destination` used by Alamofire to ensure all downloads persist. This `Destination` prepends
+    /// `Alamofire_` to the automatically generated download name and moves it within the temporary directory. Files
+    /// with this destination must be additionally moved if they should survive the system reclamation of temporary
+    /// space.
+    static let defaultDestination: Destination = { url, _ in
+        (defaultDestinationURL(url), [])
+    }
+
+    /// Default `URL` creation closure. Creates a `URL` in the temporary directory with `Alamofire_` prepended to the
+    /// provided file name.
+    static let defaultDestinationURL: (URL) -> URL = { url in
+        let filename = "Alamofire_\(url.lastPathComponent)"
+        let destination = url.deletingLastPathComponent().appendingPathComponent(filename)
+
+        return destination
+    }
+
+    // MARK: Downloadable
+
+    /// Type describing the source used to create the underlying `URLSessionDownloadTask`.
+    public enum Downloadable {
+        /// Download should be started from the `URLRequest` produced by the associated `URLRequestConvertible` value.
+        case request(URLRequestConvertible)
+        /// Download should be started from the associated resume `Data` value.
+        case resumeData(Data)
+    }
+
+    // MARK: Mutable State
+
+    /// Type containing all mutable state for `DownloadRequest` instances.
+    private struct DownloadRequestMutableState {
+        /// Possible resume `Data` produced when cancelling the instance.
+        var resumeData: Data?
+        /// `URL` to which `Data` is being downloaded.
+        var fileURL: URL?
+    }
+
+    /// Protected mutable state specific to `DownloadRequest`.
+    @Protected
+    private var mutableDownloadState = DownloadRequestMutableState()
+
+    /// If the download is resumable and is eventually cancelled or fails, this value may be used to resume the download
+    /// using the `download(resumingWith data:)` API.
+    ///
+    /// - Note: For more information about `resumeData`, see [Apple's documentation](https://developer.apple.com/documentation/foundation/urlsessiondownloadtask/1411634-cancel).
+    public var resumeData: Data? {
+        #if !(os(Linux) || os(Windows))
+        return mutableDownloadState.resumeData ?? error?.downloadResumeData
+        #else
+        return mutableDownloadState.resumeData
+        #endif
+    }
+
+    /// If the download is successful, the `URL` where the file was downloaded.
+    public var fileURL: URL? { mutableDownloadState.fileURL }
+
+    // MARK: Initial State
+
+    /// `Downloadable` value used for this instance.
+    public let downloadable: Downloadable
+    /// The `Destination` to which the downloaded file is moved.
+    let destination: Destination
+
+    /// Creates a `DownloadRequest` using the provided parameters.
+    ///
+    /// - Parameters:
+    ///   - id:                 `UUID` used for the `Hashable` and `Equatable` implementations. `UUID()` by default.
+    ///   - downloadable:       `Downloadable` value used to create `URLSessionDownloadTasks` for the instance.
+    ///   - underlyingQueue:    `DispatchQueue` on which all internal `Request` work is performed.
+    ///   - serializationQueue: `DispatchQueue` on which all serialization work is performed. By default targets
+    ///                         `underlyingQueue`, but can be passed another queue from a `Session`.
+    ///   - eventMonitor:       `EventMonitor` called for event callbacks from internal `Request` actions.
+    ///   - interceptor:        `RequestInterceptor` used throughout the request lifecycle.
+    ///   - delegate:           `RequestDelegate` that provides an interface to actions not performed by the `Request`
+    ///   - destination:        `Destination` closure used to move the downloaded file to its final location.
+    init(id: UUID = UUID(),
+         downloadable: Downloadable,
+         underlyingQueue: DispatchQueue,
+         serializationQueue: DispatchQueue,
+         eventMonitor: EventMonitor?,
+         interceptor: RequestInterceptor?,
+         delegate: RequestDelegate,
+         destination: @escaping Destination) {
+        self.downloadable = downloadable
+        self.destination = destination
+
+        super.init(id: id,
+                   underlyingQueue: underlyingQueue,
+                   serializationQueue: serializationQueue,
+                   eventMonitor: eventMonitor,
+                   interceptor: interceptor,
+                   delegate: delegate)
+    }
+
+    override func reset() {
+        super.reset()
+
+        $mutableDownloadState.write {
+            $0.resumeData = nil
+            $0.fileURL = nil
+        }
+    }
+
+    /// Called when a download has finished.
+    ///
+    /// - Parameters:
+    ///   - task:   `URLSessionTask` that finished the download.
+    ///   - result: `Result` of the automatic move to `destination`.
+    func didFinishDownloading(using task: URLSessionTask, with result: Result<URL, AFError>) {
+        eventMonitor?.request(self, didFinishDownloadingUsing: task, with: result)
+
+        switch result {
+        case let .success(url): mutableDownloadState.fileURL = url
+        case let .failure(error): self.error = error
+        }
+    }
+
+    /// Updates the `downloadProgress` using the provided values.
+    ///
+    /// - Parameters:
+    ///   - bytesWritten:              Total bytes written so far.
+    ///   - totalBytesExpectedToWrite: Total bytes expected to write.
+    func updateDownloadProgress(bytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        downloadProgress.totalUnitCount = totalBytesExpectedToWrite
+        downloadProgress.completedUnitCount += bytesWritten
+
+        downloadProgressHandler?.queue.async { self.downloadProgressHandler?.handler(self.downloadProgress) }
+    }
+
+    override func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
+        session.downloadTask(with: request)
+    }
+
+    /// Creates a `URLSessionTask` from the provided resume data.
+    ///
+    /// - Parameters:
+    ///   - data:    `Data` used to resume the download.
+    ///   - session: `URLSession` used to create the `URLSessionTask`.
+    ///
+    /// - Returns:   The `URLSessionTask` created.
+    public func task(forResumeData data: Data, using session: URLSession) -> URLSessionTask {
+        session.downloadTask(withResumeData: data)
+    }
+
+    /// Cancels the instance. Once cancelled, a `DownloadRequest` can no longer be resumed or suspended.
+    ///
+    /// - Note: This method will NOT produce resume data. If you wish to cancel and produce resume data, use
+    ///         `cancel(producingResumeData:)` or `cancel(byProducingResumeData:)`.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    override public func cancel() -> Self {
+        cancel(producingResumeData: false)
+    }
+
+    /// Cancels the instance, optionally producing resume data. Once cancelled, a `DownloadRequest` can no longer be
+    /// resumed or suspended.
+    ///
+    /// - Note: If `producingResumeData` is `true`, the `resumeData` property will be populated with any resume data, if
+    ///         available.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    public func cancel(producingResumeData shouldProduceResumeData: Bool) -> Self {
+        cancel(optionallyProducingResumeData: shouldProduceResumeData ? { _ in } : nil)
+    }
+
+    /// Cancels the instance while producing resume data. Once cancelled, a `DownloadRequest` can no longer be resumed
+    /// or suspended.
+    ///
+    /// - Note: The resume data passed to the completion handler will also be available on the instance's `resumeData`
+    ///         property.
+    ///
+    /// - Parameter completionHandler: The completion handler that is called when the download has been successfully
+    ///                                cancelled. It is not guaranteed to be called on a particular queue, so you may
+    ///                                want use an appropriate queue to perform your work.
+    ///
+    /// - Returns:                     The instance.
+    @discardableResult
+    public func cancel(byProducingResumeData completionHandler: @escaping (_ data: Data?) -> Void) -> Self {
+        cancel(optionallyProducingResumeData: completionHandler)
+    }
+
+    /// Internal implementation of cancellation that optionally takes a resume data handler. If no handler is passed,
+    /// cancellation is performed without producing resume data.
+    ///
+    /// - Parameter completionHandler: Optional resume data handler.
+    ///
+    /// - Returns:                     The instance.
+    private func cancel(optionallyProducingResumeData completionHandler: ((_ resumeData: Data?) -> Void)?) -> Self {
+        $mutableState.write { mutableState in
+            guard mutableState.state.canTransitionTo(.cancelled) else { return }
+
+            mutableState.state = .cancelled
+
+            underlyingQueue.async { self.didCancel() }
+
+            guard let task = mutableState.tasks.last as? URLSessionDownloadTask, task.state != .completed else {
+                underlyingQueue.async { self.finish() }
+                return
+            }
+
+            if let completionHandler = completionHandler {
+                // Resume to ensure metrics are gathered.
+                task.resume()
+                task.cancel { resumeData in
+                    self.mutableDownloadState.resumeData = resumeData
+                    self.underlyingQueue.async { self.didCancelTask(task) }
+                    completionHandler(resumeData)
+                }
+            } else {
+                // Resume to ensure metrics are gathered.
+                task.resume()
+                task.cancel(byProducingResumeData: { _ in })
+                self.underlyingQueue.async { self.didCancelTask(task) }
+            }
+        }
+
+        return self
+    }
+
+    /// Validates the request, using the specified closure.
+    ///
+    /// - Note: If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Parameter validation: `Validation` closure to validate the response.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func validate(_ validation: @escaping Validation) -> Self {
+        let validator: () -> Void = { [unowned self] in
+            guard self.error == nil, let response = self.response else { return }
+
+            let result = validation(self.request, response, self.fileURL)
+
+            if case let .failure(error) = result {
+                self.error = error.asAFError(or: .responseValidationFailed(reason: .customValidationFailed(error: error)))
+            }
+
+            self.eventMonitor?.request(self,
+                                       didValidateRequest: self.request,
+                                       response: response,
+                                       fileURL: self.fileURL,
+                                       withResult: result)
+        }
+
+        $validators.write { $0.append(validator) }
+
+        return self
+    }
+}
+
+// MARK: - UploadRequest
+
+/// `DataRequest` subclass which handles `Data` upload from memory, file, or stream using `URLSessionUploadTask`.
+public class UploadRequest: DataRequest {
+    /// Type describing the origin of the upload, whether `Data`, file, or stream.
+    public enum Uploadable {
+        /// Upload from the provided `Data` value.
+        case data(Data)
+        /// Upload from the provided file `URL`, as well as a `Bool` determining whether the source file should be
+        /// automatically removed once uploaded.
+        case file(URL, shouldRemove: Bool)
+        /// Upload from the provided `InputStream`.
+        case stream(InputStream)
+    }
+
+    // MARK: Initial State
+
+    /// The `UploadableConvertible` value used to produce the `Uploadable` value for this instance.
+    public let upload: UploadableConvertible
+
+    /// `FileManager` used to perform cleanup tasks, including the removal of multipart form encoded payloads written
+    /// to disk.
+    public let fileManager: FileManager
+
+    // MARK: Mutable State
+
+    /// `Uploadable` value used by the instance.
+    public var uploadable: Uploadable?
+
+    /// Creates an `UploadRequest` using the provided parameters.
+    ///
+    /// - Parameters:
+    ///   - id:                 `UUID` used for the `Hashable` and `Equatable` implementations. `UUID()` by default.
+    ///   - convertible:        `UploadConvertible` value used to determine the type of upload to be performed.
+    ///   - underlyingQueue:    `DispatchQueue` on which all internal `Request` work is performed.
+    ///   - serializationQueue: `DispatchQueue` on which all serialization work is performed. By default targets
+    ///                         `underlyingQueue`, but can be passed another queue from a `Session`.
+    ///   - eventMonitor:       `EventMonitor` called for event callbacks from internal `Request` actions.
+    ///   - interceptor:        `RequestInterceptor` used throughout the request lifecycle.
+    ///   - delegate:           `RequestDelegate` that provides an interface to actions not performed by the `Request`.
+    init(id: UUID = UUID(),
+         convertible: UploadConvertible,
+         underlyingQueue: DispatchQueue,
+         serializationQueue: DispatchQueue,
+         eventMonitor: EventMonitor?,
+         interceptor: RequestInterceptor?,
+         fileManager: FileManager,
+         delegate: RequestDelegate) {
+        upload = convertible
+        self.fileManager = fileManager
+
+        super.init(id: id,
+                   convertible: convertible,
+                   underlyingQueue: underlyingQueue,
+                   serializationQueue: serializationQueue,
+                   eventMonitor: eventMonitor,
+                   interceptor: interceptor,
+                   delegate: delegate)
+    }
+
+    /// Called when the `Uploadable` value has been created from the `UploadConvertible`.
+    ///
+    /// - Parameter uploadable: The `Uploadable` that was created.
+    func didCreateUploadable(_ uploadable: Uploadable) {
+        self.uploadable = uploadable
+
+        eventMonitor?.request(self, didCreateUploadable: uploadable)
+    }
+
+    /// Called when the `Uploadable` value could not be created.
+    ///
+    /// - Parameter error: `AFError` produced by the failure.
+    func didFailToCreateUploadable(with error: AFError) {
+        self.error = error
+
+        eventMonitor?.request(self, didFailToCreateUploadableWithError: error)
+
+        retryOrFinish(error: error)
+    }
+
+    override func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
+        guard let uploadable = uploadable else {
+            fatalError("Attempting to create a URLSessionUploadTask when Uploadable value doesn't exist.")
+        }
+
+        switch uploadable {
+        case let .data(data): return session.uploadTask(with: request, from: data)
+        case let .file(url, _): return session.uploadTask(with: request, fromFile: url)
+        case .stream: return session.uploadTask(withStreamedRequest: request)
+        }
+    }
+
+    override func reset() {
+        // Uploadable must be recreated on every retry.
+        uploadable = nil
+
+        super.reset()
+    }
+
+    /// Produces the `InputStream` from `uploadable`, if it can.
+    ///
+    /// - Note: Calling this method with a non-`.stream` `Uploadable` is a logic error and will crash.
+    ///
+    /// - Returns: The `InputStream`.
+    func inputStream() -> InputStream {
+        guard let uploadable = uploadable else {
+            fatalError("Attempting to access the input stream but the uploadable doesn't exist.")
+        }
+
+        guard case let .stream(stream) = uploadable else {
+            fatalError("Attempted to access the stream of an UploadRequest that wasn't created with one.")
+        }
+
+        eventMonitor?.request(self, didProvideInputStream: stream)
+
+        return stream
+    }
+
+    override public func cleanup() {
+        defer { super.cleanup() }
+
+        guard
+            let uploadable = self.uploadable,
+            case let .file(url, shouldRemove) = uploadable,
+            shouldRemove
+        else { return }
+
+        try? fileManager.removeItem(at: url)
+    }
+}
+
+/// A type that can produce an `UploadRequest.Uploadable` value.
+public protocol UploadableConvertible {
+    /// Produces an `UploadRequest.Uploadable` value from the instance.
+    ///
+    /// - Returns: The `UploadRequest.Uploadable`.
+    /// - Throws:  Any `Error` produced during creation.
+    func createUploadable() throws -> UploadRequest.Uploadable
+}
+
+extension UploadRequest.Uploadable: UploadableConvertible {
+    public func createUploadable() throws -> UploadRequest.Uploadable {
+        self
+    }
+}
+
+/// A type that can be converted to an upload, whether from an `UploadRequest.Uploadable` or `URLRequestConvertible`.
+public protocol UploadConvertible: UploadableConvertible & URLRequestConvertible {}

Pods/Alamofire/Source/RequestInterceptor.swift

@@ -0,0 +1,244 @@
+//
+//  RequestInterceptor.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A type that can inspect and optionally adapt a `URLRequest` in some manner if necessary.
+public protocol RequestAdapter {
+    /// Inspects and adapts the specified `URLRequest` in some manner and calls the completion handler with the Result.
+    ///
+    /// - Parameters:
+    ///   - urlRequest: The `URLRequest` to adapt.
+    ///   - session:    The `Session` that will execute the `URLRequest`.
+    ///   - completion: The completion handler that must be called when adaptation is complete.
+    func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void)
+}
+
+// MARK: -
+
+/// Outcome of determination whether retry is necessary.
+public enum RetryResult {
+    /// Retry should be attempted immediately.
+    case retry
+    /// Retry should be attempted after the associated `TimeInterval`.
+    case retryWithDelay(TimeInterval)
+    /// Do not retry.
+    case doNotRetry
+    /// Do not retry due to the associated `Error`.
+    case doNotRetryWithError(Error)
+}
+
+extension RetryResult {
+    var retryRequired: Bool {
+        switch self {
+        case .retry, .retryWithDelay: return true
+        default: return false
+        }
+    }
+
+    var delay: TimeInterval? {
+        switch self {
+        case let .retryWithDelay(delay): return delay
+        default: return nil
+        }
+    }
+
+    var error: Error? {
+        guard case let .doNotRetryWithError(error) = self else { return nil }
+        return error
+    }
+}
+
+/// A type that determines whether a request should be retried after being executed by the specified session manager
+/// and encountering an error.
+public protocol RequestRetrier {
+    /// Determines whether the `Request` should be retried by calling the `completion` closure.
+    ///
+    /// This operation is fully asynchronous. Any amount of time can be taken to determine whether the request needs
+    /// to be retried. The one requirement is that the completion closure is called to ensure the request is properly
+    /// cleaned up after.
+    ///
+    /// - Parameters:
+    ///   - request:    `Request` that failed due to the provided `Error`.
+    ///   - session:    `Session` that produced the `Request`.
+    ///   - error:      `Error` encountered while executing the `Request`.
+    ///   - completion: Completion closure to be executed when a retry decision has been determined.
+    func retry(_ request: Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void)
+}
+
+// MARK: -
+
+/// Type that provides both `RequestAdapter` and `RequestRetrier` functionality.
+public protocol RequestInterceptor: RequestAdapter, RequestRetrier {}
+
+extension RequestInterceptor {
+    public func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
+        completion(.success(urlRequest))
+    }
+
+    public func retry(_ request: Request,
+                      for session: Session,
+                      dueTo error: Error,
+                      completion: @escaping (RetryResult) -> Void) {
+        completion(.doNotRetry)
+    }
+}
+
+/// `RequestAdapter` closure definition.
+public typealias AdaptHandler = (URLRequest, Session, _ completion: @escaping (Result<URLRequest, Error>) -> Void) -> Void
+/// `RequestRetrier` closure definition.
+public typealias RetryHandler = (Request, Session, Error, _ completion: @escaping (RetryResult) -> Void) -> Void
+
+// MARK: -
+
+/// Closure-based `RequestAdapter`.
+open class Adapter: RequestInterceptor {
+    private let adaptHandler: AdaptHandler
+
+    /// Creates an instance using the provided closure.
+    ///
+    /// - Parameter adaptHandler: `AdaptHandler` closure to be executed when handling request adaptation.
+    public init(_ adaptHandler: @escaping AdaptHandler) {
+        self.adaptHandler = adaptHandler
+    }
+
+    open func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
+        adaptHandler(urlRequest, session, completion)
+    }
+}
+
+// MARK: -
+
+/// Closure-based `RequestRetrier`.
+open class Retrier: RequestInterceptor {
+    private let retryHandler: RetryHandler
+
+    /// Creates an instance using the provided closure.
+    ///
+    /// - Parameter retryHandler: `RetryHandler` closure to be executed when handling request retry.
+    public init(_ retryHandler: @escaping RetryHandler) {
+        self.retryHandler = retryHandler
+    }
+
+    open func retry(_ request: Request,
+                    for session: Session,
+                    dueTo error: Error,
+                    completion: @escaping (RetryResult) -> Void) {
+        retryHandler(request, session, error, completion)
+    }
+}
+
+// MARK: -
+
+/// `RequestInterceptor` which can use multiple `RequestAdapter` and `RequestRetrier` values.
+open class Interceptor: RequestInterceptor {
+    /// All `RequestAdapter`s associated with the instance. These adapters will be run until one fails.
+    public let adapters: [RequestAdapter]
+    /// All `RequestRetrier`s associated with the instance. These retriers will be run one at a time until one triggers retry.
+    public let retriers: [RequestRetrier]
+
+    /// Creates an instance from `AdaptHandler` and `RetryHandler` closures.
+    ///
+    /// - Parameters:
+    ///   - adaptHandler: `AdaptHandler` closure to be used.
+    ///   - retryHandler: `RetryHandler` closure to be used.
+    public init(adaptHandler: @escaping AdaptHandler, retryHandler: @escaping RetryHandler) {
+        adapters = [Adapter(adaptHandler)]
+        retriers = [Retrier(retryHandler)]
+    }
+
+    /// Creates an instance from `RequestAdapter` and `RequestRetrier` values.
+    ///
+    /// - Parameters:
+    ///   - adapter: `RequestAdapter` value to be used.
+    ///   - retrier: `RequestRetrier` value to be used.
+    public init(adapter: RequestAdapter, retrier: RequestRetrier) {
+        adapters = [adapter]
+        retriers = [retrier]
+    }
+
+    /// Creates an instance from the arrays of `RequestAdapter` and `RequestRetrier` values.
+    ///
+    /// - Parameters:
+    ///   - adapters:     `RequestAdapter` values to be used.
+    ///   - retriers:     `RequestRetrier` values to be used.
+    ///   - interceptors: `RequestInterceptor`s to be used.
+    public init(adapters: [RequestAdapter] = [], retriers: [RequestRetrier] = [], interceptors: [RequestInterceptor] = []) {
+        self.adapters = adapters + interceptors
+        self.retriers = retriers + interceptors
+    }
+
+    open func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
+        adapt(urlRequest, for: session, using: adapters, completion: completion)
+    }
+
+    private func adapt(_ urlRequest: URLRequest,
+                       for session: Session,
+                       using adapters: [RequestAdapter],
+                       completion: @escaping (Result<URLRequest, Error>) -> Void) {
+        var pendingAdapters = adapters
+
+        guard !pendingAdapters.isEmpty else { completion(.success(urlRequest)); return }
+
+        let adapter = pendingAdapters.removeFirst()
+
+        adapter.adapt(urlRequest, for: session) { result in
+            switch result {
+            case let .success(urlRequest):
+                self.adapt(urlRequest, for: session, using: pendingAdapters, completion: completion)
+            case .failure:
+                completion(result)
+            }
+        }
+    }
+
+    open func retry(_ request: Request,
+                    for session: Session,
+                    dueTo error: Error,
+                    completion: @escaping (RetryResult) -> Void) {
+        retry(request, for: session, dueTo: error, using: retriers, completion: completion)
+    }
+
+    private func retry(_ request: Request,
+                       for session: Session,
+                       dueTo error: Error,
+                       using retriers: [RequestRetrier],
+                       completion: @escaping (RetryResult) -> Void) {
+        var pendingRetriers = retriers
+
+        guard !pendingRetriers.isEmpty else { completion(.doNotRetry); return }
+
+        let retrier = pendingRetriers.removeFirst()
+
+        retrier.retry(request, for: session, dueTo: error) { result in
+            switch result {
+            case .retry, .retryWithDelay, .doNotRetryWithError:
+                completion(result)
+            case .doNotRetry:
+                // Only continue to the next retrier if retry was not triggered and no error was encountered
+                self.retry(request, for: session, dueTo: error, using: pendingRetriers, completion: completion)
+            }
+        }
+    }
+}

Pods/Alamofire/Source/RequestTaskMap.swift

@@ -0,0 +1,149 @@
+//
+//  RequestTaskMap.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A type that maintains a two way, one to one map of `URLSessionTask`s to `Request`s.
+struct RequestTaskMap {
+    private typealias Events = (completed: Bool, metricsGathered: Bool)
+
+    private var tasksToRequests: [URLSessionTask: Request]
+    private var requestsToTasks: [Request: URLSessionTask]
+    private var taskEvents: [URLSessionTask: Events]
+
+    var requests: [Request] {
+        Array(tasksToRequests.values)
+    }
+
+    init(tasksToRequests: [URLSessionTask: Request] = [:],
+         requestsToTasks: [Request: URLSessionTask] = [:],
+         taskEvents: [URLSessionTask: (completed: Bool, metricsGathered: Bool)] = [:]) {
+        self.tasksToRequests = tasksToRequests
+        self.requestsToTasks = requestsToTasks
+        self.taskEvents = taskEvents
+    }
+
+    subscript(_ request: Request) -> URLSessionTask? {
+        get { requestsToTasks[request] }
+        set {
+            guard let newValue = newValue else {
+                guard let task = requestsToTasks[request] else {
+                    fatalError("RequestTaskMap consistency error: no task corresponding to request found.")
+                }
+
+                requestsToTasks.removeValue(forKey: request)
+                tasksToRequests.removeValue(forKey: task)
+                taskEvents.removeValue(forKey: task)
+
+                return
+            }
+
+            requestsToTasks[request] = newValue
+            tasksToRequests[newValue] = request
+            taskEvents[newValue] = (completed: false, metricsGathered: false)
+        }
+    }
+
+    subscript(_ task: URLSessionTask) -> Request? {
+        get { tasksToRequests[task] }
+        set {
+            guard let newValue = newValue else {
+                guard let request = tasksToRequests[task] else {
+                    fatalError("RequestTaskMap consistency error: no request corresponding to task found.")
+                }
+
+                tasksToRequests.removeValue(forKey: task)
+                requestsToTasks.removeValue(forKey: request)
+                taskEvents.removeValue(forKey: task)
+
+                return
+            }
+
+            tasksToRequests[task] = newValue
+            requestsToTasks[newValue] = task
+            taskEvents[task] = (completed: false, metricsGathered: false)
+        }
+    }
+
+    var count: Int {
+        precondition(tasksToRequests.count == requestsToTasks.count,
+                     "RequestTaskMap.count invalid, requests.count: \(tasksToRequests.count) != tasks.count: \(requestsToTasks.count)")
+
+        return tasksToRequests.count
+    }
+
+    var eventCount: Int {
+        precondition(taskEvents.count == count, "RequestTaskMap.eventCount invalid, count: \(count) != taskEvents.count: \(taskEvents.count)")
+
+        return taskEvents.count
+    }
+
+    var isEmpty: Bool {
+        precondition(tasksToRequests.isEmpty == requestsToTasks.isEmpty,
+                     "RequestTaskMap.isEmpty invalid, requests.isEmpty: \(tasksToRequests.isEmpty) != tasks.isEmpty: \(requestsToTasks.isEmpty)")
+
+        return tasksToRequests.isEmpty
+    }
+
+    var isEventsEmpty: Bool {
+        precondition(taskEvents.isEmpty == isEmpty, "RequestTaskMap.isEventsEmpty invalid, isEmpty: \(isEmpty) != taskEvents.isEmpty: \(taskEvents.isEmpty)")
+
+        return taskEvents.isEmpty
+    }
+
+    mutating func disassociateIfNecessaryAfterGatheringMetricsForTask(_ task: URLSessionTask) -> Bool {
+        guard let events = taskEvents[task] else {
+            fatalError("RequestTaskMap consistency error: no events corresponding to task found.")
+        }
+
+        switch (events.completed, events.metricsGathered) {
+        case (_, true): fatalError("RequestTaskMap consistency error: duplicate metricsGatheredForTask call.")
+        case (false, false): taskEvents[task] = (completed: false, metricsGathered: true); return false
+        case (true, false): self[task] = nil; return true
+        }
+    }
+
+    mutating func disassociateIfNecessaryAfterCompletingTask(_ task: URLSessionTask) -> Bool {
+        guard let events = taskEvents[task] else {
+            fatalError("RequestTaskMap consistency error: no events corresponding to task found.")
+        }
+
+        switch (events.completed, events.metricsGathered) {
+        case (true, _): fatalError("RequestTaskMap consistency error: duplicate completionReceivedForTask call.")
+        #if os(Linux) // Linux doesn't gather metrics, so unconditionally remove the reference and return true.
+        default: self[task] = nil; return true
+        #else
+        case (false, false):
+            if #available(macOS 10.12, iOS 10, watchOS 7, tvOS 10, *) {
+                taskEvents[task] = (completed: true, metricsGathered: false); return false
+            } else {
+                // watchOS < 7 doesn't gather metrics, so unconditionally remove the reference and return true.
+                self[task] = nil; return true
+            }
+        case (false, true):
+            self[task] = nil; return true
+        #endif
+        }
+    }
+}

Pods/Alamofire/Source/Response.swift

@@ -0,0 +1,454 @@
+//
+//  Response.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Default type of `DataResponse` returned by Alamofire, with an `AFError` `Failure` type.
+public typealias AFDataResponse<Success> = DataResponse<Success, AFError>
+/// Default type of `DownloadResponse` returned by Alamofire, with an `AFError` `Failure` type.
+public typealias AFDownloadResponse<Success> = DownloadResponse<Success, AFError>
+
+/// Type used to store all values associated with a serialized response of a `DataRequest` or `UploadRequest`.
+public struct DataResponse<Success, Failure: Error> {
+    /// The URL request sent to the server.
+    public let request: URLRequest?
+
+    /// The server's response to the URL request.
+    public let response: HTTPURLResponse?
+
+    /// The data returned by the server.
+    public let data: Data?
+
+    /// The final metrics of the response.
+    ///
+    /// - Note: Due to `FB7624529`, collection of `URLSessionTaskMetrics` on watchOS is currently disabled.`
+    ///
+    public let metrics: URLSessionTaskMetrics?
+
+    /// The time taken to serialize the response.
+    public let serializationDuration: TimeInterval
+
+    /// The result of response serialization.
+    public let result: Result<Success, Failure>
+
+    /// Returns the associated value of the result if it is a success, `nil` otherwise.
+    public var value: Success? { result.success }
+
+    /// Returns the associated error value if the result if it is a failure, `nil` otherwise.
+    public var error: Failure? { result.failure }
+
+    /// Creates a `DataResponse` instance with the specified parameters derived from the response serialization.
+    ///
+    /// - Parameters:
+    ///   - request:               The `URLRequest` sent to the server.
+    ///   - response:              The `HTTPURLResponse` from the server.
+    ///   - data:                  The `Data` returned by the server.
+    ///   - metrics:               The `URLSessionTaskMetrics` of the `DataRequest` or `UploadRequest`.
+    ///   - serializationDuration: The duration taken by serialization.
+    ///   - result:                The `Result` of response serialization.
+    public init(request: URLRequest?,
+                response: HTTPURLResponse?,
+                data: Data?,
+                metrics: URLSessionTaskMetrics?,
+                serializationDuration: TimeInterval,
+                result: Result<Success, Failure>) {
+        self.request = request
+        self.response = response
+        self.data = data
+        self.metrics = metrics
+        self.serializationDuration = serializationDuration
+        self.result = result
+    }
+}
+
+// MARK: -
+
+extension DataResponse: CustomStringConvertible, CustomDebugStringConvertible {
+    /// The textual representation used when written to an output stream, which includes whether the result was a
+    /// success or failure.
+    public var description: String {
+        "\(result)"
+    }
+
+    /// The debug textual representation used when written to an output stream, which includes (if available) a summary
+    /// of the `URLRequest`, the request's headers and body (if decodable as a `String` below 100KB); the
+    /// `HTTPURLResponse`'s status code, headers, and body; the duration of the network and serialization actions; and
+    /// the `Result` of serialization.
+    public var debugDescription: String {
+        guard let urlRequest = request else { return "[Request]: None\n[Result]: \(result)" }
+
+        let requestDescription = DebugDescription.description(of: urlRequest)
+
+        let responseDescription = response.map { response in
+            let responseBodyDescription = DebugDescription.description(for: data, headers: response.headers)
+
+            return """
+            \(DebugDescription.description(of: response))
+                \(responseBodyDescription.indentingNewlines())
+            """
+        } ?? "[Response]: None"
+
+        let networkDuration = metrics.map { "\($0.taskInterval.duration)s" } ?? "None"
+
+        return """
+        \(requestDescription)
+        \(responseDescription)
+        [Network Duration]: \(networkDuration)
+        [Serialization Duration]: \(serializationDuration)s
+        [Result]: \(result)
+        """
+    }
+}
+
+// MARK: -
+
+extension DataResponse {
+    /// Evaluates the specified closure when the result of this `DataResponse` is a success, passing the unwrapped
+    /// result value as a parameter.
+    ///
+    /// Use the `map` method with a closure that does not throw. For example:
+    ///
+    ///     let possibleData: DataResponse<Data> = ...
+    ///     let possibleInt = possibleData.map { $0.count }
+    ///
+    /// - parameter transform: A closure that takes the success value of the instance's result.
+    ///
+    /// - returns: A `DataResponse` whose result wraps the value returned by the given closure. If this instance's
+    ///            result is a failure, returns a response wrapping the same failure.
+    public func map<NewSuccess>(_ transform: (Success) -> NewSuccess) -> DataResponse<NewSuccess, Failure> {
+        DataResponse<NewSuccess, Failure>(request: request,
+                                          response: response,
+                                          data: data,
+                                          metrics: metrics,
+                                          serializationDuration: serializationDuration,
+                                          result: result.map(transform))
+    }
+
+    /// Evaluates the given closure when the result of this `DataResponse` is a success, passing the unwrapped result
+    /// value as a parameter.
+    ///
+    /// Use the `tryMap` method with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: DataResponse<Data> = ...
+    ///     let possibleObject = possibleData.tryMap {
+    ///         try JSONSerialization.jsonObject(with: $0)
+    ///     }
+    ///
+    /// - parameter transform: A closure that takes the success value of the instance's result.
+    ///
+    /// - returns: A success or failure `DataResponse` depending on the result of the given closure. If this instance's
+    ///            result is a failure, returns the same failure.
+    public func tryMap<NewSuccess>(_ transform: (Success) throws -> NewSuccess) -> DataResponse<NewSuccess, Error> {
+        DataResponse<NewSuccess, Error>(request: request,
+                                        response: response,
+                                        data: data,
+                                        metrics: metrics,
+                                        serializationDuration: serializationDuration,
+                                        result: result.tryMap(transform))
+    }
+
+    /// Evaluates the specified closure when the `DataResponse` is a failure, passing the unwrapped error as a parameter.
+    ///
+    /// Use the `mapError` function with a closure that does not throw. For example:
+    ///
+    ///     let possibleData: DataResponse<Data> = ...
+    ///     let withMyError = possibleData.mapError { MyError.error($0) }
+    ///
+    /// - Parameter transform: A closure that takes the error of the instance.
+    ///
+    /// - Returns: A `DataResponse` instance containing the result of the transform.
+    public func mapError<NewFailure: Error>(_ transform: (Failure) -> NewFailure) -> DataResponse<Success, NewFailure> {
+        DataResponse<Success, NewFailure>(request: request,
+                                          response: response,
+                                          data: data,
+                                          metrics: metrics,
+                                          serializationDuration: serializationDuration,
+                                          result: result.mapError(transform))
+    }
+
+    /// Evaluates the specified closure when the `DataResponse` is a failure, passing the unwrapped error as a parameter.
+    ///
+    /// Use the `tryMapError` function with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: DataResponse<Data> = ...
+    ///     let possibleObject = possibleData.tryMapError {
+    ///         try someFailableFunction(taking: $0)
+    ///     }
+    ///
+    /// - Parameter transform: A throwing closure that takes the error of the instance.
+    ///
+    /// - Returns: A `DataResponse` instance containing the result of the transform.
+    public func tryMapError<NewFailure: Error>(_ transform: (Failure) throws -> NewFailure) -> DataResponse<Success, Error> {
+        DataResponse<Success, Error>(request: request,
+                                     response: response,
+                                     data: data,
+                                     metrics: metrics,
+                                     serializationDuration: serializationDuration,
+                                     result: result.tryMapError(transform))
+    }
+}
+
+// MARK: -
+
+/// Used to store all data associated with a serialized response of a download request.
+public struct DownloadResponse<Success, Failure: Error> {
+    /// The URL request sent to the server.
+    public let request: URLRequest?
+
+    /// The server's response to the URL request.
+    public let response: HTTPURLResponse?
+
+    /// The final destination URL of the data returned from the server after it is moved.
+    public let fileURL: URL?
+
+    /// The resume data generated if the request was cancelled.
+    public let resumeData: Data?
+
+    /// The final metrics of the response.
+    ///
+    /// - Note: Due to `FB7624529`, collection of `URLSessionTaskMetrics` on watchOS is currently disabled.`
+    ///
+    public let metrics: URLSessionTaskMetrics?
+
+    /// The time taken to serialize the response.
+    public let serializationDuration: TimeInterval
+
+    /// The result of response serialization.
+    public let result: Result<Success, Failure>
+
+    /// Returns the associated value of the result if it is a success, `nil` otherwise.
+    public var value: Success? { result.success }
+
+    /// Returns the associated error value if the result if it is a failure, `nil` otherwise.
+    public var error: Failure? { result.failure }
+
+    /// Creates a `DownloadResponse` instance with the specified parameters derived from response serialization.
+    ///
+    /// - Parameters:
+    ///   - request:               The `URLRequest` sent to the server.
+    ///   - response:              The `HTTPURLResponse` from the server.
+    ///   - temporaryURL:          The temporary destination `URL` of the data returned from the server.
+    ///   - destinationURL:        The final destination `URL` of the data returned from the server, if it was moved.
+    ///   - resumeData:            The resume `Data` generated if the request was cancelled.
+    ///   - metrics:               The `URLSessionTaskMetrics` of the `DownloadRequest`.
+    ///   - serializationDuration: The duration taken by serialization.
+    ///   - result:                The `Result` of response serialization.
+    public init(request: URLRequest?,
+                response: HTTPURLResponse?,
+                fileURL: URL?,
+                resumeData: Data?,
+                metrics: URLSessionTaskMetrics?,
+                serializationDuration: TimeInterval,
+                result: Result<Success, Failure>) {
+        self.request = request
+        self.response = response
+        self.fileURL = fileURL
+        self.resumeData = resumeData
+        self.metrics = metrics
+        self.serializationDuration = serializationDuration
+        self.result = result
+    }
+}
+
+// MARK: -
+
+extension DownloadResponse: CustomStringConvertible, CustomDebugStringConvertible {
+    /// The textual representation used when written to an output stream, which includes whether the result was a
+    /// success or failure.
+    public var description: String {
+        "\(result)"
+    }
+
+    /// The debug textual representation used when written to an output stream, which includes the URL request, the URL
+    /// response, the temporary and destination URLs, the resume data, the durations of the network and serialization
+    /// actions, and the response serialization result.
+    public var debugDescription: String {
+        guard let urlRequest = request else { return "[Request]: None\n[Result]: \(result)" }
+
+        let requestDescription = DebugDescription.description(of: urlRequest)
+        let responseDescription = response.map(DebugDescription.description(of:)) ?? "[Response]: None"
+        let networkDuration = metrics.map { "\($0.taskInterval.duration)s" } ?? "None"
+        let resumeDataDescription = resumeData.map { "\($0)" } ?? "None"
+
+        return """
+        \(requestDescription)
+        \(responseDescription)
+        [File URL]: \(fileURL?.path ?? "None")
+        [Resume Data]: \(resumeDataDescription)
+        [Network Duration]: \(networkDuration)
+        [Serialization Duration]: \(serializationDuration)s
+        [Result]: \(result)
+        """
+    }
+}
+
+// MARK: -
+
+extension DownloadResponse {
+    /// Evaluates the given closure when the result of this `DownloadResponse` is a success, passing the unwrapped
+    /// result value as a parameter.
+    ///
+    /// Use the `map` method with a closure that does not throw. For example:
+    ///
+    ///     let possibleData: DownloadResponse<Data> = ...
+    ///     let possibleInt = possibleData.map { $0.count }
+    ///
+    /// - parameter transform: A closure that takes the success value of the instance's result.
+    ///
+    /// - returns: A `DownloadResponse` whose result wraps the value returned by the given closure. If this instance's
+    ///            result is a failure, returns a response wrapping the same failure.
+    public func map<NewSuccess>(_ transform: (Success) -> NewSuccess) -> DownloadResponse<NewSuccess, Failure> {
+        DownloadResponse<NewSuccess, Failure>(request: request,
+                                              response: response,
+                                              fileURL: fileURL,
+                                              resumeData: resumeData,
+                                              metrics: metrics,
+                                              serializationDuration: serializationDuration,
+                                              result: result.map(transform))
+    }
+
+    /// Evaluates the given closure when the result of this `DownloadResponse` is a success, passing the unwrapped
+    /// result value as a parameter.
+    ///
+    /// Use the `tryMap` method with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: DownloadResponse<Data> = ...
+    ///     let possibleObject = possibleData.tryMap {
+    ///         try JSONSerialization.jsonObject(with: $0)
+    ///     }
+    ///
+    /// - parameter transform: A closure that takes the success value of the instance's result.
+    ///
+    /// - returns: A success or failure `DownloadResponse` depending on the result of the given closure. If this
+    /// instance's result is a failure, returns the same failure.
+    public func tryMap<NewSuccess>(_ transform: (Success) throws -> NewSuccess) -> DownloadResponse<NewSuccess, Error> {
+        DownloadResponse<NewSuccess, Error>(request: request,
+                                            response: response,
+                                            fileURL: fileURL,
+                                            resumeData: resumeData,
+                                            metrics: metrics,
+                                            serializationDuration: serializationDuration,
+                                            result: result.tryMap(transform))
+    }
+
+    /// Evaluates the specified closure when the `DownloadResponse` is a failure, passing the unwrapped error as a parameter.
+    ///
+    /// Use the `mapError` function with a closure that does not throw. For example:
+    ///
+    ///     let possibleData: DownloadResponse<Data> = ...
+    ///     let withMyError = possibleData.mapError { MyError.error($0) }
+    ///
+    /// - Parameter transform: A closure that takes the error of the instance.
+    ///
+    /// - Returns: A `DownloadResponse` instance containing the result of the transform.
+    public func mapError<NewFailure: Error>(_ transform: (Failure) -> NewFailure) -> DownloadResponse<Success, NewFailure> {
+        DownloadResponse<Success, NewFailure>(request: request,
+                                              response: response,
+                                              fileURL: fileURL,
+                                              resumeData: resumeData,
+                                              metrics: metrics,
+                                              serializationDuration: serializationDuration,
+                                              result: result.mapError(transform))
+    }
+
+    /// Evaluates the specified closure when the `DownloadResponse` is a failure, passing the unwrapped error as a parameter.
+    ///
+    /// Use the `tryMapError` function with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: DownloadResponse<Data> = ...
+    ///     let possibleObject = possibleData.tryMapError {
+    ///         try someFailableFunction(taking: $0)
+    ///     }
+    ///
+    /// - Parameter transform: A throwing closure that takes the error of the instance.
+    ///
+    /// - Returns: A `DownloadResponse` instance containing the result of the transform.
+    public func tryMapError<NewFailure: Error>(_ transform: (Failure) throws -> NewFailure) -> DownloadResponse<Success, Error> {
+        DownloadResponse<Success, Error>(request: request,
+                                         response: response,
+                                         fileURL: fileURL,
+                                         resumeData: resumeData,
+                                         metrics: metrics,
+                                         serializationDuration: serializationDuration,
+                                         result: result.tryMapError(transform))
+    }
+}
+
+private enum DebugDescription {
+    static func description(of request: URLRequest) -> String {
+        let requestSummary = "\(request.httpMethod!) \(request)"
+        let requestHeadersDescription = DebugDescription.description(for: request.headers)
+        let requestBodyDescription = DebugDescription.description(for: request.httpBody, headers: request.headers)
+
+        return """
+        [Request]: \(requestSummary)
+            \(requestHeadersDescription.indentingNewlines())
+            \(requestBodyDescription.indentingNewlines())
+        """
+    }
+
+    static func description(of response: HTTPURLResponse) -> String {
+        """
+        [Response]:
+            [Status Code]: \(response.statusCode)
+            \(DebugDescription.description(for: response.headers).indentingNewlines())
+        """
+    }
+
+    static func description(for headers: HTTPHeaders) -> String {
+        guard !headers.isEmpty else { return "[Headers]: None" }
+
+        let headerDescription = "\(headers.sorted())".indentingNewlines()
+        return """
+        [Headers]:
+            \(headerDescription)
+        """
+    }
+
+    static func description(for data: Data?,
+                            headers: HTTPHeaders,
+                            allowingPrintableTypes printableTypes: [String] = ["json", "xml", "text"],
+                            maximumLength: Int = 100_000) -> String {
+        guard let data = data, !data.isEmpty else { return "[Body]: None" }
+
+        guard
+            data.count <= maximumLength,
+            printableTypes.compactMap({ headers["Content-Type"]?.contains($0) }).contains(true)
+        else { return "[Body]: \(data.count) bytes" }
+
+        return """
+        [Body]:
+            \(String(decoding: data, as: UTF8.self)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .indentingNewlines())
+        """
+    }
+}
+
+extension String {
+    fileprivate func indentingNewlines(by spaceCount: Int = 4) -> String {
+        let spaces = String(repeating: " ", count: spaceCount)
+        return replacingOccurrences(of: "\n", with: "\n\(spaces)")
+    }
+}

Pods/Alamofire/Source/ResponseSerialization.swift

@@ -0,0 +1,1116 @@
+//
+//  ResponseSerialization.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+// MARK: Protocols
+
+/// The type to which all data response serializers must conform in order to serialize a response.
+public protocol DataResponseSerializerProtocol {
+    /// The type of serialized object to be created.
+    associatedtype SerializedObject
+
+    /// Serialize the response `Data` into the provided type..
+    ///
+    /// - Parameters:
+    ///   - request:  `URLRequest` which was used to perform the request, if any.
+    ///   - response: `HTTPURLResponse` received from the server, if any.
+    ///   - data:     `Data` returned from the server, if any.
+    ///   - error:    `Error` produced by Alamofire or the underlying `URLSession` during the request.
+    ///
+    /// - Returns:    The `SerializedObject`.
+    /// - Throws:     Any `Error` produced during serialization.
+    func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> SerializedObject
+}
+
+/// The type to which all download response serializers must conform in order to serialize a response.
+public protocol DownloadResponseSerializerProtocol {
+    /// The type of serialized object to be created.
+    associatedtype SerializedObject
+
+    /// Serialize the downloaded response `Data` from disk into the provided type..
+    ///
+    /// - Parameters:
+    ///   - request:  `URLRequest` which was used to perform the request, if any.
+    ///   - response: `HTTPURLResponse` received from the server, if any.
+    ///   - fileURL:  File `URL` to which the response data was downloaded.
+    ///   - error:    `Error` produced by Alamofire or the underlying `URLSession` during the request.
+    ///
+    /// - Returns:    The `SerializedObject`.
+    /// - Throws:     Any `Error` produced during serialization.
+    func serializeDownload(request: URLRequest?, response: HTTPURLResponse?, fileURL: URL?, error: Error?) throws -> SerializedObject
+}
+
+/// A serializer that can handle both data and download responses.
+public protocol ResponseSerializer: DataResponseSerializerProtocol & DownloadResponseSerializerProtocol {
+    /// `DataPreprocessor` used to prepare incoming `Data` for serialization.
+    var dataPreprocessor: DataPreprocessor { get }
+    /// `HTTPMethod`s for which empty response bodies are considered appropriate.
+    var emptyRequestMethods: Set<HTTPMethod> { get }
+    /// HTTP response codes for which empty response bodies are considered appropriate.
+    var emptyResponseCodes: Set<Int> { get }
+}
+
+/// Type used to preprocess `Data` before it handled by a serializer.
+public protocol DataPreprocessor {
+    /// Process           `Data` before it's handled by a serializer.
+    /// - Parameter data: The raw `Data` to process.
+    func preprocess(_ data: Data) throws -> Data
+}
+
+/// `DataPreprocessor` that returns passed `Data` without any transform.
+public struct PassthroughPreprocessor: DataPreprocessor {
+    public init() {}
+
+    public func preprocess(_ data: Data) throws -> Data { data }
+}
+
+/// `DataPreprocessor` that trims Google's typical `)]}',\n` XSSI JSON header.
+public struct GoogleXSSIPreprocessor: DataPreprocessor {
+    public init() {}
+
+    public func preprocess(_ data: Data) throws -> Data {
+        (data.prefix(6) == Data(")]}',\n".utf8)) ? data.dropFirst(6) : data
+    }
+}
+
+extension ResponseSerializer {
+    /// Default `DataPreprocessor`. `PassthroughPreprocessor` by default.
+    public static var defaultDataPreprocessor: DataPreprocessor { PassthroughPreprocessor() }
+    /// Default `HTTPMethod`s for which empty response bodies are considered appropriate. `[.head]` by default.
+    public static var defaultEmptyRequestMethods: Set<HTTPMethod> { [.head] }
+    /// HTTP response codes for which empty response bodies are considered appropriate. `[204, 205]` by default.
+    public static var defaultEmptyResponseCodes: Set<Int> { [204, 205] }
+
+    public var dataPreprocessor: DataPreprocessor { Self.defaultDataPreprocessor }
+    public var emptyRequestMethods: Set<HTTPMethod> { Self.defaultEmptyRequestMethods }
+    public var emptyResponseCodes: Set<Int> { Self.defaultEmptyResponseCodes }
+
+    /// Determines whether the `request` allows empty response bodies, if `request` exists.
+    ///
+    /// - Parameter request: `URLRequest` to evaluate.
+    ///
+    /// - Returns:           `Bool` representing the outcome of the evaluation, or `nil` if `request` was `nil`.
+    public func requestAllowsEmptyResponseData(_ request: URLRequest?) -> Bool? {
+        request.flatMap { $0.httpMethod }
+            .flatMap(HTTPMethod.init)
+            .map { emptyRequestMethods.contains($0) }
+    }
+
+    /// Determines whether the `response` allows empty response bodies, if `response` exists`.
+    ///
+    /// - Parameter response: `HTTPURLResponse` to evaluate.
+    ///
+    /// - Returns:            `Bool` representing the outcome of the evaluation, or `nil` if `response` was `nil`.
+    public func responseAllowsEmptyResponseData(_ response: HTTPURLResponse?) -> Bool? {
+        response.flatMap { $0.statusCode }
+            .map { emptyResponseCodes.contains($0) }
+    }
+
+    /// Determines whether `request` and `response` allow empty response bodies.
+    ///
+    /// - Parameters:
+    ///   - request:  `URLRequest` to evaluate.
+    ///   - response: `HTTPURLResponse` to evaluate.
+    ///
+    /// - Returns:    `true` if `request` or `response` allow empty bodies, `false` otherwise.
+    public func emptyResponseAllowed(forRequest request: URLRequest?, response: HTTPURLResponse?) -> Bool {
+        (requestAllowsEmptyResponseData(request) == true) || (responseAllowsEmptyResponseData(response) == true)
+    }
+}
+
+/// By default, any serializer declared to conform to both types will get file serialization for free, as it just feeds
+/// the data read from disk into the data response serializer.
+extension DownloadResponseSerializerProtocol where Self: DataResponseSerializerProtocol {
+    public func serializeDownload(request: URLRequest?, response: HTTPURLResponse?, fileURL: URL?, error: Error?) throws -> Self.SerializedObject {
+        guard error == nil else { throw error! }
+
+        guard let fileURL = fileURL else {
+            throw AFError.responseSerializationFailed(reason: .inputFileNil)
+        }
+
+        let data: Data
+        do {
+            data = try Data(contentsOf: fileURL)
+        } catch {
+            throw AFError.responseSerializationFailed(reason: .inputFileReadFailed(at: fileURL))
+        }
+
+        do {
+            return try serialize(request: request, response: response, data: data, error: error)
+        } catch {
+            throw error
+        }
+    }
+}
+
+// MARK: - Default
+
+extension DataRequest {
+    /// Adds a handler to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:             The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - completionHandler: The code to be executed once the request has finished.
+    ///
+    /// - Returns:             The request.
+    @discardableResult
+    public func response(queue: DispatchQueue = .main, completionHandler: @escaping (AFDataResponse<Data?>) -> Void) -> Self {
+        appendResponseSerializer {
+            // Start work that should be on the serialization queue.
+            let result = AFResult<Data?>(value: self.data, error: self.error)
+            // End work that should be on the serialization queue.
+
+            self.underlyingQueue.async {
+                let response = DataResponse(request: self.request,
+                                            response: self.response,
+                                            data: self.data,
+                                            metrics: self.metrics,
+                                            serializationDuration: 0,
+                                            result: result)
+
+                self.eventMonitor?.request(self, didParseResponse: response)
+
+                self.responseSerializerDidComplete { queue.async { completionHandler(response) } }
+            }
+        }
+
+        return self
+    }
+
+    /// Adds a handler to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:              The queue on which the completion handler is dispatched. `.main` by default
+    ///   - responseSerializer: The response serializer responsible for serializing the request, response, and data.
+    ///   - completionHandler:  The code to be executed once the request has finished.
+    ///
+    /// - Returns:              The request.
+    @discardableResult
+    public func response<Serializer: DataResponseSerializerProtocol>(queue: DispatchQueue = .main,
+                                                                     responseSerializer: Serializer,
+                                                                     completionHandler: @escaping (AFDataResponse<Serializer.SerializedObject>) -> Void)
+        -> Self {
+        appendResponseSerializer {
+            // Start work that should be on the serialization queue.
+            let start = ProcessInfo.processInfo.systemUptime
+            let result: AFResult<Serializer.SerializedObject> = Result {
+                try responseSerializer.serialize(request: self.request,
+                                                 response: self.response,
+                                                 data: self.data,
+                                                 error: self.error)
+            }.mapError { error in
+                error.asAFError(or: .responseSerializationFailed(reason: .customSerializationFailed(error: error)))
+            }
+
+            let end = ProcessInfo.processInfo.systemUptime
+            // End work that should be on the serialization queue.
+
+            self.underlyingQueue.async {
+                let response = DataResponse(request: self.request,
+                                            response: self.response,
+                                            data: self.data,
+                                            metrics: self.metrics,
+                                            serializationDuration: end - start,
+                                            result: result)
+
+                self.eventMonitor?.request(self, didParseResponse: response)
+
+                guard let serializerError = result.failure, let delegate = self.delegate else {
+                    self.responseSerializerDidComplete { queue.async { completionHandler(response) } }
+                    return
+                }
+
+                delegate.retryResult(for: self, dueTo: serializerError) { retryResult in
+                    var didComplete: (() -> Void)?
+
+                    defer {
+                        if let didComplete = didComplete {
+                            self.responseSerializerDidComplete { queue.async { didComplete() } }
+                        }
+                    }
+
+                    switch retryResult {
+                    case .doNotRetry:
+                        didComplete = { completionHandler(response) }
+
+                    case let .doNotRetryWithError(retryError):
+                        let result: AFResult<Serializer.SerializedObject> = .failure(retryError.asAFError(orFailWith: "Received retryError was not already AFError"))
+
+                        let response = DataResponse(request: self.request,
+                                                    response: self.response,
+                                                    data: self.data,
+                                                    metrics: self.metrics,
+                                                    serializationDuration: end - start,
+                                                    result: result)
+
+                        didComplete = { completionHandler(response) }
+
+                    case .retry, .retryWithDelay:
+                        delegate.retryRequest(self, withDelay: retryResult.delay)
+                    }
+                }
+            }
+        }
+
+        return self
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:             The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - completionHandler: The code to be executed once the request has finished.
+    ///
+    /// - Returns:             The request.
+    @discardableResult
+    public func response(queue: DispatchQueue = .main,
+                         completionHandler: @escaping (AFDownloadResponse<URL?>) -> Void)
+        -> Self {
+        appendResponseSerializer {
+            // Start work that should be on the serialization queue.
+            let result = AFResult<URL?>(value: self.fileURL, error: self.error)
+            // End work that should be on the serialization queue.
+
+            self.underlyingQueue.async {
+                let response = DownloadResponse(request: self.request,
+                                                response: self.response,
+                                                fileURL: self.fileURL,
+                                                resumeData: self.resumeData,
+                                                metrics: self.metrics,
+                                                serializationDuration: 0,
+                                                result: result)
+
+                self.eventMonitor?.request(self, didParseResponse: response)
+
+                self.responseSerializerDidComplete { queue.async { completionHandler(response) } }
+            }
+        }
+
+        return self
+    }
+
+    /// Adds a handler to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:              The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - responseSerializer: The response serializer responsible for serializing the request, response, and data
+    ///                         contained in the destination `URL`.
+    ///   - completionHandler:  The code to be executed once the request has finished.
+    ///
+    /// - Returns:              The request.
+    @discardableResult
+    public func response<Serializer: DownloadResponseSerializerProtocol>(queue: DispatchQueue = .main,
+                                                                         responseSerializer: Serializer,
+                                                                         completionHandler: @escaping (AFDownloadResponse<Serializer.SerializedObject>) -> Void)
+        -> Self {
+        appendResponseSerializer {
+            // Start work that should be on the serialization queue.
+            let start = ProcessInfo.processInfo.systemUptime
+            let result: AFResult<Serializer.SerializedObject> = Result {
+                try responseSerializer.serializeDownload(request: self.request,
+                                                         response: self.response,
+                                                         fileURL: self.fileURL,
+                                                         error: self.error)
+            }.mapError { error in
+                error.asAFError(or: .responseSerializationFailed(reason: .customSerializationFailed(error: error)))
+            }
+            let end = ProcessInfo.processInfo.systemUptime
+            // End work that should be on the serialization queue.
+
+            self.underlyingQueue.async {
+                let response = DownloadResponse(request: self.request,
+                                                response: self.response,
+                                                fileURL: self.fileURL,
+                                                resumeData: self.resumeData,
+                                                metrics: self.metrics,
+                                                serializationDuration: end - start,
+                                                result: result)
+
+                self.eventMonitor?.request(self, didParseResponse: response)
+
+                guard let serializerError = result.failure, let delegate = self.delegate else {
+                    self.responseSerializerDidComplete { queue.async { completionHandler(response) } }
+                    return
+                }
+
+                delegate.retryResult(for: self, dueTo: serializerError) { retryResult in
+                    var didComplete: (() -> Void)?
+
+                    defer {
+                        if let didComplete = didComplete {
+                            self.responseSerializerDidComplete { queue.async { didComplete() } }
+                        }
+                    }
+
+                    switch retryResult {
+                    case .doNotRetry:
+                        didComplete = { completionHandler(response) }
+
+                    case let .doNotRetryWithError(retryError):
+                        let result: AFResult<Serializer.SerializedObject> = .failure(retryError.asAFError(orFailWith: "Received retryError was not already AFError"))
+
+                        let response = DownloadResponse(request: self.request,
+                                                        response: self.response,
+                                                        fileURL: self.fileURL,
+                                                        resumeData: self.resumeData,
+                                                        metrics: self.metrics,
+                                                        serializationDuration: end - start,
+                                                        result: result)
+
+                        didComplete = { completionHandler(response) }
+
+                    case .retry, .retryWithDelay:
+                        delegate.retryRequest(self, withDelay: retryResult.delay)
+                    }
+                }
+            }
+        }
+
+        return self
+    }
+}
+
+// MARK: - URL
+
+/// A `DownloadResponseSerializerProtocol` that performs only `Error` checking and ensures that a downloaded `fileURL`
+/// is present.
+public struct URLResponseSerializer: DownloadResponseSerializerProtocol {
+    /// Creates an instance.
+    public init() {}
+
+    public func serializeDownload(request: URLRequest?,
+                                  response: HTTPURLResponse?,
+                                  fileURL: URL?,
+                                  error: Error?) throws -> URL {
+        guard error == nil else { throw error! }
+
+        guard let url = fileURL else {
+            throw AFError.responseSerializationFailed(reason: .inputFileNil)
+        }
+
+        return url
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler using a `URLResponseSerializer` to be called once the request is finished.
+    ///
+    /// - Parameters:
+    ///   - queue:             The queue on which the completion handler is called. `.main` by default.
+    ///   - completionHandler: A closure to be executed once the request has finished.
+    ///
+    /// - Returns:             The request.
+    @discardableResult
+    public func responseURL(queue: DispatchQueue = .main,
+                            completionHandler: @escaping (AFDownloadResponse<URL>) -> Void) -> Self {
+        response(queue: queue, responseSerializer: URLResponseSerializer(), completionHandler: completionHandler)
+    }
+}
+
+// MARK: - Data
+
+/// A `ResponseSerializer` that performs minimal response checking and returns any response `Data` as-is. By default, a
+/// request returning `nil` or no data is considered an error. However, if the request has an `HTTPMethod` or the
+/// response has an  HTTP status code valid for empty responses, then an empty `Data` value is returned.
+public final class DataResponseSerializer: ResponseSerializer {
+    public let dataPreprocessor: DataPreprocessor
+    public let emptyResponseCodes: Set<Int>
+    public let emptyRequestMethods: Set<HTTPMethod>
+
+    /// Creates an instance using the provided values.
+    ///
+    /// - Parameters:
+    ///   - dataPreprocessor:    `DataPreprocessor` used to prepare the received `Data` for serialization.
+    ///   - emptyResponseCodes:  The HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
+    ///   - emptyRequestMethods: The HTTP request methods for which empty responses are allowed. `[.head]` by default.
+    public init(dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
+                emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
+                emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) {
+        self.dataPreprocessor = dataPreprocessor
+        self.emptyResponseCodes = emptyResponseCodes
+        self.emptyRequestMethods = emptyRequestMethods
+    }
+
+    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> Data {
+        guard error == nil else { throw error! }
+
+        guard var data = data, !data.isEmpty else {
+            guard emptyResponseAllowed(forRequest: request, response: response) else {
+                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
+            }
+
+            return Data()
+        }
+
+        data = try dataPreprocessor.preprocess(data)
+
+        return data
+    }
+}
+
+extension DataRequest {
+    /// Adds a handler using a `DataResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is called. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseData(queue: DispatchQueue = .main,
+                             dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
+                             emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
+                             emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods,
+                             completionHandler: @escaping (AFDataResponse<Data>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: DataResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                            emptyResponseCodes: emptyResponseCodes,
+                                                            emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler using a `DataResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is called. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseData(queue: DispatchQueue = .main,
+                             dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
+                             emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
+                             emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods,
+                             completionHandler: @escaping (AFDownloadResponse<Data>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: DataResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                            emptyResponseCodes: emptyResponseCodes,
+                                                            emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+// MARK: - String
+
+/// A `ResponseSerializer` that decodes the response data as a `String`. By default, a request returning `nil` or no
+/// data is considered an error. However, if the request has an `HTTPMethod` or the response has an  HTTP status code
+/// valid for empty responses, then an empty `String` is returned.
+public final class StringResponseSerializer: ResponseSerializer {
+    public let dataPreprocessor: DataPreprocessor
+    /// Optional string encoding used to validate the response.
+    public let encoding: String.Encoding?
+    public let emptyResponseCodes: Set<Int>
+    public let emptyRequestMethods: Set<HTTPMethod>
+
+    /// Creates an instance with the provided values.
+    ///
+    /// - Parameters:
+    ///   - dataPreprocessor:    `DataPreprocessor` used to prepare the received `Data` for serialization.
+    ///   - encoding:            A string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  The HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
+    ///   - emptyRequestMethods: The HTTP request methods for which empty responses are allowed. `[.head]` by default.
+    public init(dataPreprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
+                encoding: String.Encoding? = nil,
+                emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
+                emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods) {
+        self.dataPreprocessor = dataPreprocessor
+        self.encoding = encoding
+        self.emptyResponseCodes = emptyResponseCodes
+        self.emptyRequestMethods = emptyRequestMethods
+    }
+
+    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> String {
+        guard error == nil else { throw error! }
+
+        guard var data = data, !data.isEmpty else {
+            guard emptyResponseAllowed(forRequest: request, response: response) else {
+                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
+            }
+
+            return ""
+        }
+
+        data = try dataPreprocessor.preprocess(data)
+
+        var convertedEncoding = encoding
+
+        if let encodingName = response?.textEncodingName, convertedEncoding == nil {
+            convertedEncoding = String.Encoding(ianaCharsetName: encodingName)
+        }
+
+        let actualEncoding = convertedEncoding ?? .isoLatin1
+
+        guard let string = String(data: data, encoding: actualEncoding) else {
+            throw AFError.responseSerializationFailed(reason: .stringSerializationFailed(encoding: actualEncoding))
+        }
+
+        return string
+    }
+}
+
+extension DataRequest {
+    /// Adds a handler using a `StringResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseString(queue: DispatchQueue = .main,
+                               dataPreprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
+                               encoding: String.Encoding? = nil,
+                               emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
+                               emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods,
+                               completionHandler: @escaping (AFDataResponse<String>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: StringResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                              encoding: encoding,
+                                                              emptyResponseCodes: emptyResponseCodes,
+                                                              emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler using a `StringResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseString(queue: DispatchQueue = .main,
+                               dataPreprocessor: DataPreprocessor = StringResponseSerializer.defaultDataPreprocessor,
+                               encoding: String.Encoding? = nil,
+                               emptyResponseCodes: Set<Int> = StringResponseSerializer.defaultEmptyResponseCodes,
+                               emptyRequestMethods: Set<HTTPMethod> = StringResponseSerializer.defaultEmptyRequestMethods,
+                               completionHandler: @escaping (AFDownloadResponse<String>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: StringResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                              encoding: encoding,
+                                                              emptyResponseCodes: emptyResponseCodes,
+                                                              emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+// MARK: - JSON
+
+/// A `ResponseSerializer` that decodes the response data using `JSONSerialization`. By default, a request returning
+/// `nil` or no data is considered an error. However, if the request has an `HTTPMethod` or the response has an
+/// HTTP status code valid for empty responses, then an `NSNull` value is returned.
+public final class JSONResponseSerializer: ResponseSerializer {
+    public let dataPreprocessor: DataPreprocessor
+    public let emptyResponseCodes: Set<Int>
+    public let emptyRequestMethods: Set<HTTPMethod>
+    /// `JSONSerialization.ReadingOptions` used when serializing a response.
+    public let options: JSONSerialization.ReadingOptions
+
+    /// Creates an instance with the provided values.
+    ///
+    /// - Parameters:
+    ///   - dataPreprocessor:    `DataPreprocessor` used to prepare the received `Data` for serialization.
+    ///   - emptyResponseCodes:  The HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
+    ///   - emptyRequestMethods: The HTTP request methods for which empty responses are allowed. `[.head]` by default.
+    ///   - options:             The options to use. `.allowFragments` by default.
+    public init(dataPreprocessor: DataPreprocessor = JSONResponseSerializer.defaultDataPreprocessor,
+                emptyResponseCodes: Set<Int> = JSONResponseSerializer.defaultEmptyResponseCodes,
+                emptyRequestMethods: Set<HTTPMethod> = JSONResponseSerializer.defaultEmptyRequestMethods,
+                options: JSONSerialization.ReadingOptions = .allowFragments) {
+        self.dataPreprocessor = dataPreprocessor
+        self.emptyResponseCodes = emptyResponseCodes
+        self.emptyRequestMethods = emptyRequestMethods
+        self.options = options
+    }
+
+    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> Any {
+        guard error == nil else { throw error! }
+
+        guard var data = data, !data.isEmpty else {
+            guard emptyResponseAllowed(forRequest: request, response: response) else {
+                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
+            }
+
+            return NSNull()
+        }
+
+        data = try dataPreprocessor.preprocess(data)
+
+        do {
+            return try JSONSerialization.jsonObject(with: data, options: options)
+        } catch {
+            throw AFError.responseSerializationFailed(reason: .jsonSerializationFailed(error: error))
+        }
+    }
+}
+
+extension DataRequest {
+    /// Adds a handler using a `JSONResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - options:             `JSONSerialization.ReadingOptions` used when parsing the response. `.allowFragments`
+    ///                          by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseJSON(queue: DispatchQueue = .main,
+                             dataPreprocessor: DataPreprocessor = JSONResponseSerializer.defaultDataPreprocessor,
+                             emptyResponseCodes: Set<Int> = JSONResponseSerializer.defaultEmptyResponseCodes,
+                             emptyRequestMethods: Set<HTTPMethod> = JSONResponseSerializer.defaultEmptyRequestMethods,
+                             options: JSONSerialization.ReadingOptions = .allowFragments,
+                             completionHandler: @escaping (AFDataResponse<Any>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: JSONResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                            emptyResponseCodes: emptyResponseCodes,
+                                                            emptyRequestMethods: emptyRequestMethods,
+                                                            options: options),
+                 completionHandler: completionHandler)
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler using a `JSONResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - options:             `JSONSerialization.ReadingOptions` used when parsing the response. `.allowFragments`
+    ///                          by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseJSON(queue: DispatchQueue = .main,
+                             dataPreprocessor: DataPreprocessor = JSONResponseSerializer.defaultDataPreprocessor,
+                             emptyResponseCodes: Set<Int> = JSONResponseSerializer.defaultEmptyResponseCodes,
+                             emptyRequestMethods: Set<HTTPMethod> = JSONResponseSerializer.defaultEmptyRequestMethods,
+                             options: JSONSerialization.ReadingOptions = .allowFragments,
+                             completionHandler: @escaping (AFDownloadResponse<Any>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: JSONResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                            emptyResponseCodes: emptyResponseCodes,
+                                                            emptyRequestMethods: emptyRequestMethods,
+                                                            options: options),
+                 completionHandler: completionHandler)
+    }
+}
+
+// MARK: - Empty
+
+/// Protocol representing an empty response. Use `T.emptyValue()` to get an instance.
+public protocol EmptyResponse {
+    /// Empty value for the conforming type.
+    ///
+    /// - Returns: Value of `Self` to use for empty values.
+    static func emptyValue() -> Self
+}
+
+/// Type representing an empty value. Use `Empty.value` to get the static instance.
+public struct Empty: Codable {
+    /// Static `Empty` instance used for all `Empty` responses.
+    public static let value = Empty()
+}
+
+extension Empty: EmptyResponse {
+    public static func emptyValue() -> Empty {
+        value
+    }
+}
+
+// MARK: - DataDecoder Protocol
+
+/// Any type which can decode `Data` into a `Decodable` type.
+public protocol DataDecoder {
+    /// Decode `Data` into the provided type.
+    ///
+    /// - Parameters:
+    ///   - type:  The `Type` to be decoded.
+    ///   - data:  The `Data` to be decoded.
+    ///
+    /// - Returns: The decoded value of type `D`.
+    /// - Throws:  Any error that occurs during decode.
+    func decode<D: Decodable>(_ type: D.Type, from data: Data) throws -> D
+}
+
+/// `JSONDecoder` automatically conforms to `DataDecoder`.
+extension JSONDecoder: DataDecoder {}
+/// `PropertyListDecoder` automatically conforms to `DataDecoder`.
+extension PropertyListDecoder: DataDecoder {}
+
+// MARK: - Decodable
+
+/// A `ResponseSerializer` that decodes the response data as a generic value using any type that conforms to
+/// `DataDecoder`. By default, this is an instance of `JSONDecoder`. Additionally, a request returning `nil` or no data
+/// is considered an error. However, if the request has an `HTTPMethod` or the response has an HTTP status code valid
+/// for empty responses then an empty value will be returned. If the decoded type conforms to `EmptyResponse`, the
+/// type's `emptyValue()` will be returned. If the decoded type is `Empty`, the `.value` instance is returned. If the
+/// decoded type *does not* conform to `EmptyResponse` and isn't `Empty`, an error will be produced.
+public final class DecodableResponseSerializer<T: Decodable>: ResponseSerializer {
+    public let dataPreprocessor: DataPreprocessor
+    /// The `DataDecoder` instance used to decode responses.
+    public let decoder: DataDecoder
+    public let emptyResponseCodes: Set<Int>
+    public let emptyRequestMethods: Set<HTTPMethod>
+
+    /// Creates an instance using the values provided.
+    ///
+    /// - Parameters:
+    ///   - dataPreprocessor:    `DataPreprocessor` used to prepare the received `Data` for serialization.
+    ///   - decoder:             The `DataDecoder`. `JSONDecoder()` by default.
+    ///   - emptyResponseCodes:  The HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
+    ///   - emptyRequestMethods: The HTTP request methods for which empty responses are allowed. `[.head]` by default.
+    public init(dataPreprocessor: DataPreprocessor = DecodableResponseSerializer.defaultDataPreprocessor,
+                decoder: DataDecoder = JSONDecoder(),
+                emptyResponseCodes: Set<Int> = DecodableResponseSerializer.defaultEmptyResponseCodes,
+                emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer.defaultEmptyRequestMethods) {
+        self.dataPreprocessor = dataPreprocessor
+        self.decoder = decoder
+        self.emptyResponseCodes = emptyResponseCodes
+        self.emptyRequestMethods = emptyRequestMethods
+    }
+
+    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> T {
+        guard error == nil else { throw error! }
+
+        guard var data = data, !data.isEmpty else {
+            guard emptyResponseAllowed(forRequest: request, response: response) else {
+                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
+            }
+
+            guard let emptyResponseType = T.self as? EmptyResponse.Type, let emptyValue = emptyResponseType.emptyValue() as? T else {
+                throw AFError.responseSerializationFailed(reason: .invalidEmptyResponse(type: "\(T.self)"))
+            }
+
+            return emptyValue
+        }
+
+        data = try dataPreprocessor.preprocess(data)
+
+        do {
+            return try decoder.decode(T.self, from: data)
+        } catch {
+            throw AFError.responseSerializationFailed(reason: .decodingFailed(error: error))
+        }
+    }
+}
+
+extension DataRequest {
+    /// Adds a handler using a `DecodableResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - type:                `Decodable` type to decode from response data.
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - decoder:             `DataDecoder` to use to decode the response. `JSONDecoder()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - options:             `JSONSerialization.ReadingOptions` used when parsing the response. `.allowFragments`
+    ///                          by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseDecodable<T: Decodable>(of type: T.Type = T.self,
+                                                queue: DispatchQueue = .main,
+                                                dataPreprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
+                                                decoder: DataDecoder = JSONDecoder(),
+                                                emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
+                                                emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods,
+                                                completionHandler: @escaping (AFDataResponse<T>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: DecodableResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                                 decoder: decoder,
+                                                                 emptyResponseCodes: emptyResponseCodes,
+                                                                 emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+extension DownloadRequest {
+    /// Adds a handler using a `DecodableResponseSerializer` to be called once the request has finished.
+    ///
+    /// - Parameters:
+    ///   - type:                `Decodable` type to decode from response data.
+    ///   - queue:               The queue on which the completion handler is dispatched. `.main` by default.
+    ///   - dataPreprocessor:    `DataPreprocessor` which processes the received `Data` before calling the
+    ///                          `completionHandler`. `PassthroughPreprocessor()` by default.
+    ///   - decoder:             `DataDecoder` to use to decode the response. `JSONDecoder()` by default.
+    ///   - encoding:            The string encoding. Defaults to `nil`, in which case the encoding will be determined
+    ///                          from the server response, falling back to the default HTTP character set, `ISO-8859-1`.
+    ///   - emptyResponseCodes:  HTTP status codes for which empty responses are always valid. `[204, 205]` by default.
+    ///   - emptyRequestMethods: `HTTPMethod`s for which empty responses are always valid. `[.head]` by default.
+    ///   - options:             `JSONSerialization.ReadingOptions` used when parsing the response. `.allowFragments`
+    ///                          by default.
+    ///   - completionHandler:   A closure to be executed once the request has finished.
+    ///
+    /// - Returns:               The request.
+    @discardableResult
+    public func responseDecodable<T: Decodable>(of type: T.Type = T.self,
+                                                queue: DispatchQueue = .main,
+                                                dataPreprocessor: DataPreprocessor = DecodableResponseSerializer<T>.defaultDataPreprocessor,
+                                                decoder: DataDecoder = JSONDecoder(),
+                                                emptyResponseCodes: Set<Int> = DecodableResponseSerializer<T>.defaultEmptyResponseCodes,
+                                                emptyRequestMethods: Set<HTTPMethod> = DecodableResponseSerializer<T>.defaultEmptyRequestMethods,
+                                                completionHandler: @escaping (AFDownloadResponse<T>) -> Void) -> Self {
+        response(queue: queue,
+                 responseSerializer: DecodableResponseSerializer(dataPreprocessor: dataPreprocessor,
+                                                                 decoder: decoder,
+                                                                 emptyResponseCodes: emptyResponseCodes,
+                                                                 emptyRequestMethods: emptyRequestMethods),
+                 completionHandler: completionHandler)
+    }
+}
+
+// MARK: - DataStreamRequest
+
+/// A type which can serialize incoming `Data`.
+public protocol DataStreamSerializer {
+    /// Type produced from the serialized `Data`.
+    associatedtype SerializedObject
+
+    /// Serializes incoming `Data` into a `SerializedObject` value.
+    ///
+    /// - Parameter data: `Data` to be serialized.
+    ///
+    /// - Throws: Any error produced during serialization.
+    func serialize(_ data: Data) throws -> SerializedObject
+}
+
+/// `DataStreamSerializer` which uses the provided `DataPreprocessor` and `DataDecoder` to serialize the incoming `Data`.
+public struct DecodableStreamSerializer<T: Decodable>: DataStreamSerializer {
+    /// `DataDecoder` used to decode incoming `Data`.
+    public let decoder: DataDecoder
+    /// `DataPreprocessor` incoming `Data` is passed through before being passed to the `DataDecoder`.
+    public let dataPreprocessor: DataPreprocessor
+
+    /// Creates an instance with the provided `DataDecoder` and `DataPreprocessor`.
+    /// - Parameters:
+    ///   - decoder: `        DataDecoder` used to decode incoming `Data`.
+    ///   - dataPreprocessor: `DataPreprocessor` used to process incoming `Data` before it's passed through the `decoder`.
+    public init(decoder: DataDecoder = JSONDecoder(), dataPreprocessor: DataPreprocessor = PassthroughPreprocessor()) {
+        self.decoder = decoder
+        self.dataPreprocessor = dataPreprocessor
+    }
+
+    public func serialize(_ data: Data) throws -> T {
+        let processedData = try dataPreprocessor.preprocess(data)
+        do {
+            return try decoder.decode(T.self, from: processedData)
+        } catch {
+            throw AFError.responseSerializationFailed(reason: .decodingFailed(error: error))
+        }
+    }
+}
+
+/// `DataStreamSerializer` which performs no serialization on incoming `Data`.
+public struct PassthroughStreamSerializer: DataStreamSerializer {
+    public func serialize(_ data: Data) throws -> Data { data }
+}
+
+/// `DataStreamSerializer` which serializes incoming stream `Data` into `UTF8`-decoded `String` values.
+public struct StringStreamSerializer: DataStreamSerializer {
+    public func serialize(_ data: Data) throws -> String {
+        String(decoding: data, as: UTF8.self)
+    }
+}
+
+extension DataStreamRequest {
+    /// Adds a `StreamHandler` which performs no parsing on incoming `Data`.
+    ///
+    /// - Parameters:
+    ///   - queue:  `DispatchQueue` on which to perform `StreamHandler` closure.
+    ///   - stream: `StreamHandler` closure called as `Data` is received. May be called multiple times.
+    ///
+    /// - Returns:  The `DataStreamRequest`.
+    @discardableResult
+    public func responseStream(on queue: DispatchQueue = .main, stream: @escaping Handler<Data, Never>) -> Self {
+        let parser = { [unowned self] (data: Data) in
+            queue.async {
+                self.capturingError {
+                    try stream(.init(event: .stream(.success(data)), token: .init(self)))
+                }
+
+                self.updateAndCompleteIfPossible()
+            }
+        }
+
+        $streamMutableState.write { $0.streams.append(parser) }
+        appendStreamCompletion(on: queue, stream: stream)
+
+        return self
+    }
+
+    /// Adds a `StreamHandler` which uses the provided `DataStreamSerializer` to process incoming `Data`.
+    ///
+    /// - Parameters:
+    ///   - serializer: `DataStreamSerializer` used to process incoming `Data`. Its work is done on the `serializationQueue`.
+    ///   - queue:      `DispatchQueue` on which to perform `StreamHandler` closure.
+    ///   - stream:     `StreamHandler` closure called as `Data` is received. May be called multiple times.
+    ///
+    /// - Returns:      The `DataStreamRequest`.
+    @discardableResult
+    public func responseStream<Serializer: DataStreamSerializer>(using serializer: Serializer,
+                                                                 on queue: DispatchQueue = .main,
+                                                                 stream: @escaping Handler<Serializer.SerializedObject, AFError>) -> Self {
+        let parser = { [unowned self] (data: Data) in
+            self.serializationQueue.async {
+                // Start work on serialization queue.
+                let result = Result { try serializer.serialize(data) }
+                    .mapError { $0.asAFError(or: .responseSerializationFailed(reason: .customSerializationFailed(error: $0))) }
+                // End work on serialization queue.
+                self.underlyingQueue.async {
+                    self.eventMonitor?.request(self, didParseStream: result)
+
+                    if result.isFailure, self.automaticallyCancelOnStreamError {
+                        self.cancel()
+                    }
+
+                    queue.async {
+                        self.capturingError {
+                            try stream(.init(event: .stream(result), token: .init(self)))
+                        }
+
+                        self.updateAndCompleteIfPossible()
+                    }
+                }
+            }
+        }
+
+        $streamMutableState.write { $0.streams.append(parser) }
+        appendStreamCompletion(on: queue, stream: stream)
+
+        return self
+    }
+
+    /// Adds a `StreamHandler` which parses incoming `Data` as a UTF8 `String`.
+    ///
+    /// - Parameters:
+    ///   - queue:      `DispatchQueue` on which to perform `StreamHandler` closure.
+    ///   - stream:     `StreamHandler` closure called as `Data` is received. May be called multiple times.
+    ///
+    /// - Returns:  The `DataStreamRequest`.
+    @discardableResult
+    public func responseStreamString(on queue: DispatchQueue = .main,
+                                     stream: @escaping Handler<String, Never>) -> Self {
+        let parser = { [unowned self] (data: Data) in
+            self.serializationQueue.async {
+                // Start work on serialization queue.
+                let string = String(decoding: data, as: UTF8.self)
+                // End work on serialization queue.
+                self.underlyingQueue.async {
+                    self.eventMonitor?.request(self, didParseStream: .success(string))
+
+                    queue.async {
+                        self.capturingError {
+                            try stream(.init(event: .stream(.success(string)), token: .init(self)))
+                        }
+
+                        self.updateAndCompleteIfPossible()
+                    }
+                }
+            }
+        }
+
+        $streamMutableState.write { $0.streams.append(parser) }
+        appendStreamCompletion(on: queue, stream: stream)
+
+        return self
+    }
+
+    private func updateAndCompleteIfPossible() {
+        $streamMutableState.write { state in
+            state.numberOfExecutingStreams -= 1
+
+            guard state.numberOfExecutingStreams == 0, !state.enqueuedCompletionEvents.isEmpty else { return }
+
+            let completionEvents = state.enqueuedCompletionEvents
+            self.underlyingQueue.async { completionEvents.forEach { $0() } }
+            state.enqueuedCompletionEvents.removeAll()
+        }
+    }
+
+    /// Adds a `StreamHandler` which parses incoming `Data` using the provided `DataDecoder`.
+    ///
+    /// - Parameters:
+    ///   - type:         `Decodable` type to parse incoming `Data` into.
+    ///   - queue:        `DispatchQueue` on which to perform `StreamHandler` closure.
+    ///   - decoder:      `DataDecoder` used to decode the incoming `Data`.
+    ///   - preprocessor: `DataPreprocessor` used to process the incoming `Data` before it's passed to the `decoder`.
+    ///   - stream:       `StreamHandler` closure called as `Data` is received. May be called multiple times.
+    ///
+    /// - Returns: The `DataStreamRequest`.
+    @discardableResult
+    public func responseStreamDecodable<T: Decodable>(of type: T.Type = T.self,
+                                                      on queue: DispatchQueue = .main,
+                                                      using decoder: DataDecoder = JSONDecoder(),
+                                                      preprocessor: DataPreprocessor = PassthroughPreprocessor(),
+                                                      stream: @escaping Handler<T, AFError>) -> Self {
+        responseStream(using: DecodableStreamSerializer<T>(decoder: decoder, dataPreprocessor: preprocessor),
+                       stream: stream)
+    }
+}

Pods/Alamofire/Source/Result+Alamofire.swift

@@ -0,0 +1,120 @@
+//
+//  Result+Alamofire.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Default type of `Result` returned by Alamofire, with an `AFError` `Failure` type.
+public typealias AFResult<Success> = Result<Success, AFError>
+
+// MARK: - Internal APIs
+
+extension Result {
+    /// Returns whether the instance is `.success`.
+    var isSuccess: Bool {
+        guard case .success = self else { return false }
+        return true
+    }
+
+    /// Returns whether the instance is `.failure`.
+    var isFailure: Bool {
+        !isSuccess
+    }
+
+    /// Returns the associated value if the result is a success, `nil` otherwise.
+    var success: Success? {
+        guard case let .success(value) = self else { return nil }
+        return value
+    }
+
+    /// Returns the associated error value if the result is a failure, `nil` otherwise.
+    var failure: Failure? {
+        guard case let .failure(error) = self else { return nil }
+        return error
+    }
+
+    /// Initializes a `Result` from value or error. Returns `.failure` if the error is non-nil, `.success` otherwise.
+    ///
+    /// - Parameters:
+    ///   - value: A value.
+    ///   - error: An `Error`.
+    init(value: Success, error: Failure?) {
+        if let error = error {
+            self = .failure(error)
+        } else {
+            self = .success(value)
+        }
+    }
+
+    /// Evaluates the specified closure when the `Result` is a success, passing the unwrapped value as a parameter.
+    ///
+    /// Use the `tryMap` method with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: Result<Data, Error> = .success(Data(...))
+    ///     let possibleObject = possibleData.tryMap {
+    ///         try JSONSerialization.jsonObject(with: $0)
+    ///     }
+    ///
+    /// - parameter transform: A closure that takes the success value of the instance.
+    ///
+    /// - returns: A `Result` containing the result of the given closure. If this instance is a failure, returns the
+    ///            same failure.
+    func tryMap<NewSuccess>(_ transform: (Success) throws -> NewSuccess) -> Result<NewSuccess, Error> {
+        switch self {
+        case let .success(value):
+            do {
+                return try .success(transform(value))
+            } catch {
+                return .failure(error)
+            }
+        case let .failure(error):
+            return .failure(error)
+        }
+    }
+
+    /// Evaluates the specified closure when the `Result` is a failure, passing the unwrapped error as a parameter.
+    ///
+    /// Use the `tryMapError` function with a closure that may throw an error. For example:
+    ///
+    ///     let possibleData: Result<Data, Error> = .success(Data(...))
+    ///     let possibleObject = possibleData.tryMapError {
+    ///         try someFailableFunction(taking: $0)
+    ///     }
+    ///
+    /// - Parameter transform: A throwing closure that takes the error of the instance.
+    ///
+    /// - Returns: A `Result` instance containing the result of the transform. If this instance is a success, returns
+    ///            the same success.
+    func tryMapError<NewFailure: Error>(_ transform: (Failure) throws -> NewFailure) -> Result<Success, Error> {
+        switch self {
+        case let .failure(error):
+            do {
+                return try .failure(transform(error))
+            } catch {
+                return .failure(error)
+            }
+        case let .success(value):
+            return .success(value)
+        }
+    }
+}

Pods/Alamofire/Source/RetryPolicy.swift

@@ -0,0 +1,370 @@
+//
+//  RetryPolicy.swift
+//
+//  Copyright (c) 2019-2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// A retry policy that retries requests using an exponential backoff for allowed HTTP methods and HTTP status codes
+/// as well as certain types of networking errors.
+open class RetryPolicy: RequestInterceptor {
+    /// The default retry limit for retry policies.
+    public static let defaultRetryLimit: UInt = 2
+
+    /// The default exponential backoff base for retry policies (must be a minimum of 2).
+    public static let defaultExponentialBackoffBase: UInt = 2
+
+    /// The default exponential backoff scale for retry policies.
+    public static let defaultExponentialBackoffScale: Double = 0.5
+
+    /// The default HTTP methods to retry.
+    /// See [RFC 2616 - Section 9.1.2](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html) for more information.
+    public static let defaultRetryableHTTPMethods: Set<HTTPMethod> = [.delete, // [Delete](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.7) - not always idempotent
+                                                                      .get, // [GET](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.3) - generally idempotent
+                                                                      .head, // [HEAD](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4) - generally idempotent
+                                                                      .options, // [OPTIONS](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.2) - inherently idempotent
+                                                                      .put, // [PUT](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.6) - not always idempotent
+                                                                      .trace // [TRACE](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.8) - inherently idempotent
+    ]
+
+    /// The default HTTP status codes to retry.
+    /// See [RFC 2616 - Section 10](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10) for more information.
+    public static let defaultRetryableHTTPStatusCodes: Set<Int> = [408, // [Request Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.9)
+                                                                   500, // [Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1)
+                                                                   502, // [Bad Gateway](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.3)
+                                                                   503, // [Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4)
+                                                                   504 // [Gateway Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.5)
+    ]
+
+    /// The default URL error codes to retry.
+    public static let defaultRetryableURLErrorCodes: Set<URLError.Code> = [// [Security] App Transport Security disallowed a connection because there is no secure network connection.
+        //   - [Disabled] ATS settings do not change at runtime.
+        // .appTransportSecurityRequiresSecureConnection,
+
+        // [System] An app or app extension attempted to connect to a background session that is already connected to a
+        // process.
+        //   - [Enabled] The other process could release the background session.
+        .backgroundSessionInUseByAnotherProcess,
+
+        // [System] The shared container identifier of the URL session configuration is needed but has not been set.
+        //   - [Disabled] Cannot change at runtime.
+        // .backgroundSessionRequiresSharedContainer,
+
+        // [System] The app is suspended or exits while a background data task is processing.
+        //   - [Enabled] App can be foregrounded or launched to recover.
+        .backgroundSessionWasDisconnected,
+
+        // [Network] The URL Loading system received bad data from the server.
+        //   - [Enabled] Server could return valid data when retrying.
+        .badServerResponse,
+
+        // [Resource] A malformed URL prevented a URL request from being initiated.
+        //   - [Disabled] URL was most likely constructed incorrectly.
+        // .badURL,
+
+        // [System] A connection was attempted while a phone call is active on a network that does not support
+        // simultaneous phone and data communication (EDGE or GPRS).
+        //   - [Enabled] Phone call could be ended to allow request to recover.
+        .callIsActive,
+
+        // [Client] An asynchronous load has been canceled.
+        //   - [Disabled] Request was cancelled by the client.
+        // .cancelled,
+
+        // [File System] A download task couldn’t close the downloaded file on disk.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotCloseFile,
+
+        // [Network] An attempt to connect to a host failed.
+        //   - [Enabled] Server or DNS lookup could recover during retry.
+        .cannotConnectToHost,
+
+        // [File System] A download task couldn’t create the downloaded file on disk because of an I/O failure.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotCreateFile,
+
+        // [Data] Content data received during a connection request had an unknown content encoding.
+        //   - [Disabled] Server is unlikely to modify the content encoding during a retry.
+        // .cannotDecodeContentData,
+
+        // [Data] Content data received during a connection request could not be decoded for a known content encoding.
+        //   - [Disabled] Server is unlikely to modify the content encoding during a retry.
+        // .cannotDecodeRawData,
+
+        // [Network] The host name for a URL could not be resolved.
+        //   - [Enabled] Server or DNS lookup could recover during retry.
+        .cannotFindHost,
+
+        // [Network] A request to load an item only from the cache could not be satisfied.
+        //   - [Enabled] Cache could be populated during a retry.
+        .cannotLoadFromNetwork,
+
+        // [File System] A download task was unable to move a downloaded file on disk.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotMoveFile,
+
+        // [File System] A download task was unable to open the downloaded file on disk.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotOpenFile,
+
+        // [Data] A task could not parse a response.
+        //   - [Disabled] Invalid response is unlikely to recover with retry.
+        // .cannotParseResponse,
+
+        // [File System] A download task was unable to remove a downloaded file from disk.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotRemoveFile,
+
+        // [File System] A download task was unable to write to the downloaded file on disk.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .cannotWriteToFile,
+
+        // [Security] A client certificate was rejected.
+        //   - [Disabled] Client certificate is unlikely to change with retry.
+        // .clientCertificateRejected,
+
+        // [Security] A client certificate was required to authenticate an SSL connection during a request.
+        //   - [Disabled] Client certificate is unlikely to be provided with retry.
+        // .clientCertificateRequired,
+
+        // [Data] The length of the resource data exceeds the maximum allowed.
+        //   - [Disabled] Resource will likely still exceed the length maximum on retry.
+        // .dataLengthExceedsMaximum,
+
+        // [System] The cellular network disallowed a connection.
+        //   - [Enabled] WiFi connection could be established during retry.
+        .dataNotAllowed,
+
+        // [Network] The host address could not be found via DNS lookup.
+        //   - [Enabled] DNS lookup could succeed during retry.
+        .dnsLookupFailed,
+
+        // [Data] A download task failed to decode an encoded file during the download.
+        //   - [Enabled] Server could correct the decoding issue with retry.
+        .downloadDecodingFailedMidStream,
+
+        // [Data] A download task failed to decode an encoded file after downloading.
+        //   - [Enabled] Server could correct the decoding issue with retry.
+        .downloadDecodingFailedToComplete,
+
+        // [File System] A file does not exist.
+        //   - [Disabled] File system error is unlikely to recover with retry.
+        // .fileDoesNotExist,
+
+        // [File System] A request for an FTP file resulted in the server responding that the file is not a plain file,
+        // but a directory.
+        //   - [Disabled] FTP directory is not likely to change to a file during a retry.
+        // .fileIsDirectory,
+
+        // [Network] A redirect loop has been detected or the threshold for number of allowable redirects has been
+        // exceeded (currently 16).
+        //   - [Disabled] The redirect loop is unlikely to be resolved within the retry window.
+        // .httpTooManyRedirects,
+
+        // [System] The attempted connection required activating a data context while roaming, but international roaming
+        // is disabled.
+        //   - [Enabled] WiFi connection could be established during retry.
+        .internationalRoamingOff,
+
+        // [Connectivity] A client or server connection was severed in the middle of an in-progress load.
+        //   - [Enabled] A network connection could be established during retry.
+        .networkConnectionLost,
+
+        // [File System] A resource couldn’t be read because of insufficient permissions.
+        //   - [Disabled] Permissions are unlikely to be granted during retry.
+        // .noPermissionsToReadFile,
+
+        // [Connectivity] A network resource was requested, but an internet connection has not been established and
+        // cannot be established automatically.
+        //   - [Enabled] A network connection could be established during retry.
+        .notConnectedToInternet,
+
+        // [Resource] A redirect was specified by way of server response code, but the server did not accompany this
+        // code with a redirect URL.
+        //   - [Disabled] The redirect URL is unlikely to be supplied during a retry.
+        // .redirectToNonExistentLocation,
+
+        // [Client] A body stream is needed but the client did not provide one.
+        //   - [Disabled] The client will be unlikely to supply a body stream during retry.
+        // .requestBodyStreamExhausted,
+
+        // [Resource] A requested resource couldn’t be retrieved.
+        //   - [Disabled] The resource is unlikely to become available during the retry window.
+        // .resourceUnavailable,
+
+        // [Security] An attempt to establish a secure connection failed for reasons that can’t be expressed more
+        // specifically.
+        //   - [Enabled] The secure connection could be established during a retry given the lack of specificity
+        //     provided by the error.
+        .secureConnectionFailed,
+
+        // [Security] A server certificate had a date which indicates it has expired, or is not yet valid.
+        //   - [Enabled] The server certificate could become valid within the retry window.
+        .serverCertificateHasBadDate,
+
+        // [Security] A server certificate was not signed by any root server.
+        //   - [Disabled] The server certificate is unlikely to change during the retry window.
+        // .serverCertificateHasUnknownRoot,
+
+        // [Security] A server certificate is not yet valid.
+        //   - [Enabled] The server certificate could become valid within the retry window.
+        .serverCertificateNotYetValid,
+
+        // [Security] A server certificate was signed by a root server that isn’t trusted.
+        //   - [Disabled] The server certificate is unlikely to become trusted within the retry window.
+        // .serverCertificateUntrusted,
+
+        // [Network] An asynchronous operation timed out.
+        //   - [Enabled] The request timed out for an unknown reason and should be retried.
+        .timedOut
+
+        // [System] The URL Loading System encountered an error that it can’t interpret.
+        //   - [Disabled] The error could not be interpreted and is unlikely to be recovered from during a retry.
+        // .unknown,
+
+        // [Resource] A properly formed URL couldn’t be handled by the framework.
+        //   - [Disabled] The URL is unlikely to change during a retry.
+        // .unsupportedURL,
+
+        // [Client] Authentication is required to access a resource.
+        //   - [Disabled] The user authentication is unlikely to be provided by retrying.
+        // .userAuthenticationRequired,
+
+        // [Client] An asynchronous request for authentication has been canceled by the user.
+        //   - [Disabled] The user cancelled authentication and explicitly took action to not retry.
+        // .userCancelledAuthentication,
+
+        // [Resource] A server reported that a URL has a non-zero content length, but terminated the network connection
+        // gracefully without sending any data.
+        //   - [Disabled] The server is unlikely to provide data during the retry window.
+        // .zeroByteResource,
+    ]
+
+    /// The total number of times the request is allowed to be retried.
+    public let retryLimit: UInt
+
+    /// The base of the exponential backoff policy (should always be greater than or equal to 2).
+    public let exponentialBackoffBase: UInt
+
+    /// The scale of the exponential backoff.
+    public let exponentialBackoffScale: Double
+
+    /// The HTTP methods that are allowed to be retried.
+    public let retryableHTTPMethods: Set<HTTPMethod>
+
+    /// The HTTP status codes that are automatically retried by the policy.
+    public let retryableHTTPStatusCodes: Set<Int>
+
+    /// The URL error codes that are automatically retried by the policy.
+    public let retryableURLErrorCodes: Set<URLError.Code>
+
+    /// Creates an `ExponentialBackoffRetryPolicy` from the specified parameters.
+    ///
+    /// - Parameters:
+    ///   - retryLimit:               The total number of times the request is allowed to be retried. `2` by default.
+    ///   - exponentialBackoffBase:   The base of the exponential backoff policy. `2` by default.
+    ///   - exponentialBackoffScale:  The scale of the exponential backoff. `0.5` by default.
+    ///   - retryableHTTPMethods:     The HTTP methods that are allowed to be retried.
+    ///                               `RetryPolicy.defaultRetryableHTTPMethods` by default.
+    ///   - retryableHTTPStatusCodes: The HTTP status codes that are automatically retried by the policy.
+    ///                               `RetryPolicy.defaultRetryableHTTPStatusCodes` by default.
+    ///   - retryableURLErrorCodes:   The URL error codes that are automatically retried by the policy.
+    ///                               `RetryPolicy.defaultRetryableURLErrorCodes` by default.
+    public init(retryLimit: UInt = RetryPolicy.defaultRetryLimit,
+                exponentialBackoffBase: UInt = RetryPolicy.defaultExponentialBackoffBase,
+                exponentialBackoffScale: Double = RetryPolicy.defaultExponentialBackoffScale,
+                retryableHTTPMethods: Set<HTTPMethod> = RetryPolicy.defaultRetryableHTTPMethods,
+                retryableHTTPStatusCodes: Set<Int> = RetryPolicy.defaultRetryableHTTPStatusCodes,
+                retryableURLErrorCodes: Set<URLError.Code> = RetryPolicy.defaultRetryableURLErrorCodes) {
+        precondition(exponentialBackoffBase >= 2, "The `exponentialBackoffBase` must be a minimum of 2.")
+
+        self.retryLimit = retryLimit
+        self.exponentialBackoffBase = exponentialBackoffBase
+        self.exponentialBackoffScale = exponentialBackoffScale
+        self.retryableHTTPMethods = retryableHTTPMethods
+        self.retryableHTTPStatusCodes = retryableHTTPStatusCodes
+        self.retryableURLErrorCodes = retryableURLErrorCodes
+    }
+
+    open func retry(_ request: Request,
+                    for session: Session,
+                    dueTo error: Error,
+                    completion: @escaping (RetryResult) -> Void) {
+        if request.retryCount < retryLimit, shouldRetry(request: request, dueTo: error) {
+            completion(.retryWithDelay(pow(Double(exponentialBackoffBase), Double(request.retryCount)) * exponentialBackoffScale))
+        } else {
+            completion(.doNotRetry)
+        }
+    }
+
+    /// Determines whether or not to retry the provided `Request`.
+    ///
+    /// - Parameters:
+    ///     - request: `Request` that failed due to the provided `Error`.
+    ///     - error:   `Error` encountered while executing the `Request`.
+    ///
+    /// - Returns:     `Bool` determining whether or not to retry the `Request`.
+    open func shouldRetry(request: Request, dueTo error: Error) -> Bool {
+        guard let httpMethod = request.request?.method, retryableHTTPMethods.contains(httpMethod) else { return false }
+
+        if let statusCode = request.response?.statusCode, retryableHTTPStatusCodes.contains(statusCode) {
+            return true
+        } else {
+            let errorCode = (error as? URLError)?.code
+            let afErrorCode = (error.asAFError?.underlyingError as? URLError)?.code
+
+            guard let code = errorCode ?? afErrorCode else { return false }
+
+            return retryableURLErrorCodes.contains(code)
+        }
+    }
+}
+
+// MARK: -
+
+/// A retry policy that automatically retries idempotent requests for network connection lost errors. For more
+/// information about retrying network connection lost errors, please refer to Apple's
+/// [technical document](https://developer.apple.com/library/content/qa/qa1941/_index.html).
+open class ConnectionLostRetryPolicy: RetryPolicy {
+    /// Creates a `ConnectionLostRetryPolicy` instance from the specified parameters.
+    ///
+    /// - Parameters:
+    ///   - retryLimit:              The total number of times the request is allowed to be retried.
+    ///                              `RetryPolicy.defaultRetryLimit` by default.
+    ///   - exponentialBackoffBase:  The base of the exponential backoff policy.
+    ///                              `RetryPolicy.defaultExponentialBackoffBase` by default.
+    ///   - exponentialBackoffScale: The scale of the exponential backoff.
+    ///                              `RetryPolicy.defaultExponentialBackoffScale` by default.
+    ///   - retryableHTTPMethods:    The idempotent http methods to retry.
+    ///                              `RetryPolicy.defaultRetryableHTTPMethods` by default.
+    public init(retryLimit: UInt = RetryPolicy.defaultRetryLimit,
+                exponentialBackoffBase: UInt = RetryPolicy.defaultExponentialBackoffBase,
+                exponentialBackoffScale: Double = RetryPolicy.defaultExponentialBackoffScale,
+                retryableHTTPMethods: Set<HTTPMethod> = RetryPolicy.defaultRetryableHTTPMethods) {
+        super.init(retryLimit: retryLimit,
+                   exponentialBackoffBase: exponentialBackoffBase,
+                   exponentialBackoffScale: exponentialBackoffScale,
+                   retryableHTTPMethods: retryableHTTPMethods,
+                   retryableHTTPStatusCodes: [],
+                   retryableURLErrorCodes: [.networkConnectionLost])
+    }
+}

Pods/Alamofire/Source/ServerTrustEvaluation.swift

@@ -0,0 +1,623 @@
+//
+//  ServerTrustPolicy.swift
+//
+//  Copyright (c) 2014-2016 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Responsible for managing the mapping of `ServerTrustEvaluating` values to given hosts.
+open class ServerTrustManager {
+    /// Determines whether all hosts for this `ServerTrustManager` must be evaluated. `true` by default.
+    public let allHostsMustBeEvaluated: Bool
+
+    /// The dictionary of policies mapped to a particular host.
+    public let evaluators: [String: ServerTrustEvaluating]
+
+    /// Initializes the `ServerTrustManager` instance with the given evaluators.
+    ///
+    /// Since different servers and web services can have different leaf certificates, intermediate and even root
+    /// certificates, it is important to have the flexibility to specify evaluation policies on a per host basis. This
+    /// allows for scenarios such as using default evaluation for host1, certificate pinning for host2, public key
+    /// pinning for host3 and disabling evaluation for host4.
+    ///
+    /// - Parameters:
+    ///   - allHostsMustBeEvaluated: The value determining whether all hosts for this instance must be evaluated. `true`
+    ///                              by default.
+    ///   - evaluators:              A dictionary of evaluators mapped to hosts.
+    public init(allHostsMustBeEvaluated: Bool = true, evaluators: [String: ServerTrustEvaluating]) {
+        self.allHostsMustBeEvaluated = allHostsMustBeEvaluated
+        self.evaluators = evaluators
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// Returns the `ServerTrustEvaluating` value for the given host, if one is set.
+    ///
+    /// By default, this method will return the policy that perfectly matches the given host. Subclasses could override
+    /// this method and implement more complex mapping implementations such as wildcards.
+    ///
+    /// - Parameter host: The host to use when searching for a matching policy.
+    ///
+    /// - Returns:        The `ServerTrustEvaluating` value for the given host if found, `nil` otherwise.
+    /// - Throws:         `AFError.serverTrustEvaluationFailed` if `allHostsMustBeEvaluated` is `true` and no matching
+    ///                   evaluators are found.
+    open func serverTrustEvaluator(forHost host: String) throws -> ServerTrustEvaluating? {
+        guard let evaluator = evaluators[host] else {
+            if allHostsMustBeEvaluated {
+                throw AFError.serverTrustEvaluationFailed(reason: .noRequiredEvaluator(host: host))
+            }
+
+            return nil
+        }
+
+        return evaluator
+    }
+    #endif
+}
+
+/// A protocol describing the API used to evaluate server trusts.
+public protocol ServerTrustEvaluating {
+    #if os(Linux) || os(Windows)
+    // Implement this once Linux/Windows has API for evaluating server trusts.
+    #else
+    /// Evaluates the given `SecTrust` value for the given `host`.
+    ///
+    /// - Parameters:
+    ///   - trust: The `SecTrust` value to evaluate.
+    ///   - host:  The host for which to evaluate the `SecTrust` value.
+    ///
+    /// - Returns: A `Bool` indicating whether the evaluator considers the `SecTrust` value valid for `host`.
+    func evaluate(_ trust: SecTrust, forHost host: String) throws
+    #endif
+}
+
+// MARK: - Server Trust Evaluators
+
+#if !(os(Linux) || os(Windows))
+/// An evaluator which uses the default server trust evaluation while allowing you to control whether to validate the
+/// host provided by the challenge. Applications are encouraged to always validate the host in production environments
+/// to guarantee the validity of the server's certificate chain.
+public final class DefaultTrustEvaluator: ServerTrustEvaluating {
+    private let validateHost: Bool
+
+    /// Creates a `DefaultTrustEvaluator`.
+    ///
+    /// - Parameter validateHost: Determines whether or not the evaluator should validate the host. `true` by default.
+    public init(validateHost: Bool = true) {
+        self.validateHost = validateHost
+    }
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        if validateHost {
+            try trust.af.performValidation(forHost: host)
+        }
+
+        try trust.af.performDefaultValidation(forHost: host)
+    }
+}
+
+/// An evaluator which Uses the default and revoked server trust evaluations allowing you to control whether to validate
+/// the host provided by the challenge as well as specify the revocation flags for testing for revoked certificates.
+/// Apple platforms did not start testing for revoked certificates automatically until iOS 10.1, macOS 10.12 and tvOS
+/// 10.1 which is demonstrated in our TLS tests. Applications are encouraged to always validate the host in production
+/// environments to guarantee the validity of the server's certificate chain.
+public final class RevocationTrustEvaluator: ServerTrustEvaluating {
+    /// Represents the options to be use when evaluating the status of a certificate.
+    /// Only Revocation Policy Constants are valid, and can be found in [Apple's documentation](https://developer.apple.com/documentation/security/certificate_key_and_trust_services/policies/1563600-revocation_policy_constants).
+    public struct Options: OptionSet {
+        /// Perform revocation checking using the CRL (Certification Revocation List) method.
+        public static let crl = Options(rawValue: kSecRevocationCRLMethod)
+        /// Consult only locally cached replies; do not use network access.
+        public static let networkAccessDisabled = Options(rawValue: kSecRevocationNetworkAccessDisabled)
+        /// Perform revocation checking using OCSP (Online Certificate Status Protocol).
+        public static let ocsp = Options(rawValue: kSecRevocationOCSPMethod)
+        /// Prefer CRL revocation checking over OCSP; by default, OCSP is preferred.
+        public static let preferCRL = Options(rawValue: kSecRevocationPreferCRL)
+        /// Require a positive response to pass the policy. If the flag is not set, revocation checking is done on a
+        /// "best attempt" basis, where failure to reach the server is not considered fatal.
+        public static let requirePositiveResponse = Options(rawValue: kSecRevocationRequirePositiveResponse)
+        /// Perform either OCSP or CRL checking. The checking is performed according to the method(s) specified in the
+        /// certificate and the value of `preferCRL`.
+        public static let any = Options(rawValue: kSecRevocationUseAnyAvailableMethod)
+
+        /// The raw value of the option.
+        public let rawValue: CFOptionFlags
+
+        /// Creates an `Options` value with the given `CFOptionFlags`.
+        ///
+        /// - Parameter rawValue: The `CFOptionFlags` value to initialize with.
+        public init(rawValue: CFOptionFlags) {
+            self.rawValue = rawValue
+        }
+    }
+
+    private let performDefaultValidation: Bool
+    private let validateHost: Bool
+    private let options: Options
+
+    /// Creates a `RevocationTrustEvaluator`.
+    ///
+    /// - Note: Default and host validation will fail when using this evaluator with self-signed certificates. Use
+    ///         `PinnedCertificatesTrustEvaluator` if you need to use self-signed certificates.
+    ///
+    /// - Parameters:
+    ///   - performDefaultValidation:     Determines whether default validation should be performed in addition to
+    ///                                   evaluating the pinned certificates. `true` by default.
+    ///   - validateHost:                 Determines whether or not the evaluator should validate the host, in addition
+    ///                                   to performing the default evaluation, even if `performDefaultValidation` is
+    ///                                   `false`. `true` by default.
+    ///   - options:                      The `Options` to use to check the revocation status of the certificate. `.any`
+    ///                                   by default.
+    public init(performDefaultValidation: Bool = true, validateHost: Bool = true, options: Options = .any) {
+        self.performDefaultValidation = performDefaultValidation
+        self.validateHost = validateHost
+        self.options = options
+    }
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        if performDefaultValidation {
+            try trust.af.performDefaultValidation(forHost: host)
+        }
+
+        if validateHost {
+            try trust.af.performValidation(forHost: host)
+        }
+
+        if #available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *) {
+            try trust.af.evaluate(afterApplying: SecPolicy.af.revocation(options: options))
+        } else {
+            try trust.af.validate(policy: SecPolicy.af.revocation(options: options)) { status, result in
+                AFError.serverTrustEvaluationFailed(reason: .revocationCheckFailed(output: .init(host, trust, status, result), options: options))
+            }
+        }
+    }
+}
+
+/// Uses the pinned certificates to validate the server trust. The server trust is considered valid if one of the pinned
+/// certificates match one of the server certificates. By validating both the certificate chain and host, certificate
+/// pinning provides a very secure form of server trust validation mitigating most, if not all, MITM attacks.
+/// Applications are encouraged to always validate the host and require a valid certificate chain in production
+/// environments.
+public final class PinnedCertificatesTrustEvaluator: ServerTrustEvaluating {
+    private let certificates: [SecCertificate]
+    private let acceptSelfSignedCertificates: Bool
+    private let performDefaultValidation: Bool
+    private let validateHost: Bool
+
+    /// Creates a `PinnedCertificatesTrustEvaluator`.
+    ///
+    /// - Parameters:
+    ///   - certificates:                 The certificates to use to evaluate the trust. All `cer`, `crt`, and `der`
+    ///                                   certificates in `Bundle.main` by default.
+    ///   - acceptSelfSignedCertificates: Adds the provided certificates as anchors for the trust evaluation, allowing
+    ///                                   self-signed certificates to pass. `false` by default. THIS SETTING SHOULD BE
+    ///                                   FALSE IN PRODUCTION!
+    ///   - performDefaultValidation:     Determines whether default validation should be performed in addition to
+    ///                                   evaluating the pinned certificates. `true` by default.
+    ///   - validateHost:                 Determines whether or not the evaluator should validate the host, in addition
+    ///                                   to performing the default evaluation, even if `performDefaultValidation` is
+    ///                                   `false`. `true` by default.
+    public init(certificates: [SecCertificate] = Bundle.main.af.certificates,
+                acceptSelfSignedCertificates: Bool = false,
+                performDefaultValidation: Bool = true,
+                validateHost: Bool = true) {
+        self.certificates = certificates
+        self.acceptSelfSignedCertificates = acceptSelfSignedCertificates
+        self.performDefaultValidation = performDefaultValidation
+        self.validateHost = validateHost
+    }
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        guard !certificates.isEmpty else {
+            throw AFError.serverTrustEvaluationFailed(reason: .noCertificatesFound)
+        }
+
+        if acceptSelfSignedCertificates {
+            try trust.af.setAnchorCertificates(certificates)
+        }
+
+        if performDefaultValidation {
+            try trust.af.performDefaultValidation(forHost: host)
+        }
+
+        if validateHost {
+            try trust.af.performValidation(forHost: host)
+        }
+
+        let serverCertificatesData = Set(trust.af.certificateData)
+        let pinnedCertificatesData = Set(certificates.af.data)
+        let pinnedCertificatesInServerData = !serverCertificatesData.isDisjoint(with: pinnedCertificatesData)
+        if !pinnedCertificatesInServerData {
+            throw AFError.serverTrustEvaluationFailed(reason: .certificatePinningFailed(host: host,
+                                                                                        trust: trust,
+                                                                                        pinnedCertificates: certificates,
+                                                                                        serverCertificates: trust.af.certificates))
+        }
+    }
+}
+
+/// Uses the pinned public keys to validate the server trust. The server trust is considered valid if one of the pinned
+/// public keys match one of the server certificate public keys. By validating both the certificate chain and host,
+/// public key pinning provides a very secure form of server trust validation mitigating most, if not all, MITM attacks.
+/// Applications are encouraged to always validate the host and require a valid certificate chain in production
+/// environments.
+public final class PublicKeysTrustEvaluator: ServerTrustEvaluating {
+    private let keys: [SecKey]
+    private let performDefaultValidation: Bool
+    private let validateHost: Bool
+
+    /// Creates a `PublicKeysTrustEvaluator`.
+    ///
+    /// - Note: Default and host validation will fail when using this evaluator with self-signed certificates. Use
+    ///         `PinnedCertificatesTrustEvaluator` if you need to use self-signed certificates.
+    ///
+    /// - Parameters:
+    ///   - keys:                     The `SecKey`s to use to validate public keys. Defaults to the public keys of all
+    ///                               certificates included in the main bundle.
+    ///   - performDefaultValidation: Determines whether default validation should be performed in addition to
+    ///                               evaluating the pinned certificates. `true` by default.
+    ///   - validateHost:             Determines whether or not the evaluator should validate the host, in addition to
+    ///                               performing the default evaluation, even if `performDefaultValidation` is `false`.
+    ///                               `true` by default.
+    public init(keys: [SecKey] = Bundle.main.af.publicKeys,
+                performDefaultValidation: Bool = true,
+                validateHost: Bool = true) {
+        self.keys = keys
+        self.performDefaultValidation = performDefaultValidation
+        self.validateHost = validateHost
+    }
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        guard !keys.isEmpty else {
+            throw AFError.serverTrustEvaluationFailed(reason: .noPublicKeysFound)
+        }
+
+        if performDefaultValidation {
+            try trust.af.performDefaultValidation(forHost: host)
+        }
+
+        if validateHost {
+            try trust.af.performValidation(forHost: host)
+        }
+
+        let pinnedKeysInServerKeys: Bool = {
+            for serverPublicKey in trust.af.publicKeys {
+                for pinnedPublicKey in keys {
+                    if serverPublicKey == pinnedPublicKey {
+                        return true
+                    }
+                }
+            }
+            return false
+        }()
+
+        if !pinnedKeysInServerKeys {
+            throw AFError.serverTrustEvaluationFailed(reason: .publicKeyPinningFailed(host: host,
+                                                                                      trust: trust,
+                                                                                      pinnedKeys: keys,
+                                                                                      serverKeys: trust.af.publicKeys))
+        }
+    }
+}
+
+/// Uses the provided evaluators to validate the server trust. The trust is only considered valid if all of the
+/// evaluators consider it valid.
+public final class CompositeTrustEvaluator: ServerTrustEvaluating {
+    private let evaluators: [ServerTrustEvaluating]
+
+    /// Creates a `CompositeTrustEvaluator`.
+    ///
+    /// - Parameter evaluators: The `ServerTrustEvaluating` values used to evaluate the server trust.
+    public init(evaluators: [ServerTrustEvaluating]) {
+        self.evaluators = evaluators
+    }
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        try evaluators.evaluate(trust, forHost: host)
+    }
+}
+
+/// Disables all evaluation which in turn will always consider any server trust as valid.
+///
+/// - Note: Instead of disabling server trust evaluation, it's a better idea to configure systems to properly trust test
+///         certificates, as outlined in [this Apple tech note](https://developer.apple.com/library/archive/qa/qa1948/_index.html).
+///
+/// **THIS EVALUATOR SHOULD NEVER BE USED IN PRODUCTION!**
+@available(*, deprecated, renamed: "DisabledTrustEvaluator", message: "DisabledEvaluator has been renamed DisabledTrustEvaluator.")
+public typealias DisabledEvaluator = DisabledTrustEvaluator
+
+/// Disables all evaluation which in turn will always consider any server trust as valid.
+///
+///
+/// - Note: Instead of disabling server trust evaluation, it's a better idea to configure systems to properly trust test
+///         certificates, as outlined in [this Apple tech note](https://developer.apple.com/library/archive/qa/qa1948/_index.html).
+///
+/// **THIS EVALUATOR SHOULD NEVER BE USED IN PRODUCTION!**
+public final class DisabledTrustEvaluator: ServerTrustEvaluating {
+    /// Creates an instance.
+    public init() {}
+
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {}
+}
+
+// MARK: - Extensions
+
+extension Array where Element == ServerTrustEvaluating {
+    #if os(Linux) || os(Windows)
+    // Add this same convenience method for Linux/Windows.
+    #else
+    /// Evaluates the given `SecTrust` value for the given `host`.
+    ///
+    /// - Parameters:
+    ///   - trust: The `SecTrust` value to evaluate.
+    ///   - host:  The host for which to evaluate the `SecTrust` value.
+    ///
+    /// - Returns: Whether or not the evaluator considers the `SecTrust` value valid for `host`.
+    public func evaluate(_ trust: SecTrust, forHost host: String) throws {
+        for evaluator in self {
+            try evaluator.evaluate(trust, forHost: host)
+        }
+    }
+    #endif
+}
+
+extension Bundle: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType: Bundle {
+    /// Returns all valid `cer`, `crt`, and `der` certificates in the bundle.
+    public var certificates: [SecCertificate] {
+        paths(forResourcesOfTypes: [".cer", ".CER", ".crt", ".CRT", ".der", ".DER"]).compactMap { path in
+            guard
+                let certificateData = try? Data(contentsOf: URL(fileURLWithPath: path)) as CFData,
+                let certificate = SecCertificateCreateWithData(nil, certificateData) else { return nil }
+
+            return certificate
+        }
+    }
+
+    /// Returns all public keys for the valid certificates in the bundle.
+    public var publicKeys: [SecKey] {
+        certificates.af.publicKeys
+    }
+
+    /// Returns all pathnames for the resources identified by the provided file extensions.
+    ///
+    /// - Parameter types: The filename extensions locate.
+    ///
+    /// - Returns:         All pathnames for the given filename extensions.
+    public func paths(forResourcesOfTypes types: [String]) -> [String] {
+        Array(Set(types.flatMap { type.paths(forResourcesOfType: $0, inDirectory: nil) }))
+    }
+}
+
+extension SecTrust: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == SecTrust {
+    /// Evaluates `self` after applying the `SecPolicy` value provided.
+    ///
+    /// - Parameter policy: The `SecPolicy` to apply to `self` before evaluation.
+    ///
+    /// - Throws:           Any `Error` from applying the `SecPolicy` or from evaluation.
+    @available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *)
+    public func evaluate(afterApplying policy: SecPolicy) throws {
+        try apply(policy: policy).af.evaluate()
+    }
+
+    /// Attempts to validate `self` using the `SecPolicy` provided and transforming any error produced using the closure passed.
+    ///
+    /// - Parameters:
+    ///   - policy:        The `SecPolicy` used to evaluate `self`.
+    ///   - errorProducer: The closure used transform the failed `OSStatus` and `SecTrustResultType`.
+    /// - Throws:          Any `Error` from applying the `policy`, or the result of `errorProducer` if validation fails.
+    @available(iOS, introduced: 10, deprecated: 12, renamed: "evaluate(afterApplying:)")
+    @available(macOS, introduced: 10.12, deprecated: 10.14, renamed: "evaluate(afterApplying:)")
+    @available(tvOS, introduced: 10, deprecated: 12, renamed: "evaluate(afterApplying:)")
+    @available(watchOS, introduced: 3, deprecated: 5, renamed: "evaluate(afterApplying:)")
+    public func validate(policy: SecPolicy, errorProducer: (_ status: OSStatus, _ result: SecTrustResultType) -> Error) throws {
+        try apply(policy: policy).af.validate(errorProducer: errorProducer)
+    }
+
+    /// Applies a `SecPolicy` to `self`, throwing if it fails.
+    ///
+    /// - Parameter policy: The `SecPolicy`.
+    ///
+    /// - Returns: `self`, with the policy applied.
+    /// - Throws: An `AFError.serverTrustEvaluationFailed` instance with a `.policyApplicationFailed` reason.
+    public func apply(policy: SecPolicy) throws -> SecTrust {
+        let status = SecTrustSetPolicies(type, policy)
+
+        guard status.af.isSuccess else {
+            throw AFError.serverTrustEvaluationFailed(reason: .policyApplicationFailed(trust: type,
+                                                                                       policy: policy,
+                                                                                       status: status))
+        }
+
+        return type
+    }
+
+    /// Evaluate `self`, throwing an `Error` if evaluation fails.
+    ///
+    /// - Throws: `AFError.serverTrustEvaluationFailed` with reason `.trustValidationFailed` and associated error from
+    ///           the underlying evaluation.
+    @available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *)
+    public func evaluate() throws {
+        var error: CFError?
+        let evaluationSucceeded = SecTrustEvaluateWithError(type, &error)
+
+        if !evaluationSucceeded {
+            throw AFError.serverTrustEvaluationFailed(reason: .trustEvaluationFailed(error: error))
+        }
+    }
+
+    /// Validate `self`, passing any failure values through `errorProducer`.
+    ///
+    /// - Parameter errorProducer: The closure used to transform the failed `OSStatus` and `SecTrustResultType` into an
+    ///                            `Error`.
+    /// - Throws:                  The `Error` produced by the `errorProducer` closure.
+    @available(iOS, introduced: 10, deprecated: 12, renamed: "evaluate()")
+    @available(macOS, introduced: 10.12, deprecated: 10.14, renamed: "evaluate()")
+    @available(tvOS, introduced: 10, deprecated: 12, renamed: "evaluate()")
+    @available(watchOS, introduced: 3, deprecated: 5, renamed: "evaluate()")
+    public func validate(errorProducer: (_ status: OSStatus, _ result: SecTrustResultType) -> Error) throws {
+        var result = SecTrustResultType.invalid
+        let status = SecTrustEvaluate(type, &result)
+
+        guard status.af.isSuccess && result.af.isSuccess else {
+            throw errorProducer(status, result)
+        }
+    }
+
+    /// Sets a custom certificate chain on `self`, allowing full validation of a self-signed certificate and its chain.
+    ///
+    /// - Parameter certificates: The `SecCertificate`s to add to the chain.
+    /// - Throws:                 Any error produced when applying the new certificate chain.
+    public func setAnchorCertificates(_ certificates: [SecCertificate]) throws {
+        // Add additional anchor certificates.
+        let status = SecTrustSetAnchorCertificates(type, certificates as CFArray)
+        guard status.af.isSuccess else {
+            throw AFError.serverTrustEvaluationFailed(reason: .settingAnchorCertificatesFailed(status: status,
+                                                                                               certificates: certificates))
+        }
+
+        // Trust only the set anchor certs.
+        let onlyStatus = SecTrustSetAnchorCertificatesOnly(type, true)
+        guard onlyStatus.af.isSuccess else {
+            throw AFError.serverTrustEvaluationFailed(reason: .settingAnchorCertificatesFailed(status: onlyStatus,
+                                                                                               certificates: certificates))
+        }
+    }
+
+    /// The public keys contained in `self`.
+    public var publicKeys: [SecKey] {
+        certificates.af.publicKeys
+    }
+
+    /// The `SecCertificate`s contained i `self`.
+    public var certificates: [SecCertificate] {
+        (0..<SecTrustGetCertificateCount(type)).compactMap { index in
+            SecTrustGetCertificateAtIndex(type, index)
+        }
+    }
+
+    /// The `Data` values for all certificates contained in `self`.
+    public var certificateData: [Data] {
+        certificates.af.data
+    }
+
+    /// Validates `self` after applying `SecPolicy.af.default`. This evaluation does not validate the hostname.
+    ///
+    /// - Parameter host: The hostname, used only in the error output if validation fails.
+    /// - Throws: An `AFError.serverTrustEvaluationFailed` instance with a `.defaultEvaluationFailed` reason.
+    public func performDefaultValidation(forHost host: String) throws {
+        if #available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *) {
+            try evaluate(afterApplying: SecPolicy.af.default)
+        } else {
+            try validate(policy: SecPolicy.af.default) { status, result in
+                AFError.serverTrustEvaluationFailed(reason: .defaultEvaluationFailed(output: .init(host, type, status, result)))
+            }
+        }
+    }
+
+    /// Validates `self` after applying `SecPolicy.af.hostname(host)`, which performs the default validation as well as
+    /// hostname validation.
+    ///
+    /// - Parameter host: The hostname to use in the validation.
+    /// - Throws:         An `AFError.serverTrustEvaluationFailed` instance with a `.defaultEvaluationFailed` reason.
+    public func performValidation(forHost host: String) throws {
+        if #available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *) {
+            try evaluate(afterApplying: SecPolicy.af.hostname(host))
+        } else {
+            try validate(policy: SecPolicy.af.hostname(host)) { status, result in
+                AFError.serverTrustEvaluationFailed(reason: .hostValidationFailed(output: .init(host, type, status, result)))
+            }
+        }
+    }
+}
+
+extension SecPolicy: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == SecPolicy {
+    /// Creates a `SecPolicy` instance which will validate server certificates but not require a host name match.
+    public static let `default` = SecPolicyCreateSSL(true, nil)
+
+    /// Creates a `SecPolicy` instance which will validate server certificates and much match the provided hostname.
+    ///
+    /// - Parameter hostname: The hostname to validate against.
+    ///
+    /// - Returns:            The `SecPolicy`.
+    public static func hostname(_ hostname: String) -> SecPolicy {
+        SecPolicyCreateSSL(true, hostname as CFString)
+    }
+
+    /// Creates a `SecPolicy` which checks the revocation of certificates.
+    ///
+    /// - Parameter options: The `RevocationTrustEvaluator.Options` for evaluation.
+    ///
+    /// - Returns:           The `SecPolicy`.
+    /// - Throws:            An `AFError.serverTrustEvaluationFailed` error with reason `.revocationPolicyCreationFailed`
+    ///                      if the policy cannot be created.
+    public static func revocation(options: RevocationTrustEvaluator.Options) throws -> SecPolicy {
+        guard let policy = SecPolicyCreateRevocation(options.rawValue) else {
+            throw AFError.serverTrustEvaluationFailed(reason: .revocationPolicyCreationFailed)
+        }
+
+        return policy
+    }
+}
+
+extension Array: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == [SecCertificate] {
+    /// All `Data` values for the contained `SecCertificate`s.
+    public var data: [Data] {
+        type.map { SecCertificateCopyData($0) as Data }
+    }
+
+    /// All public `SecKey` values for the contained `SecCertificate`s.
+    public var publicKeys: [SecKey] {
+        type.compactMap { $0.af.publicKey }
+    }
+}
+
+extension SecCertificate: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == SecCertificate {
+    /// The public key for `self`, if it can be extracted.
+    public var publicKey: SecKey? {
+        let policy = SecPolicyCreateBasicX509()
+        var trust: SecTrust?
+        let trustCreationStatus = SecTrustCreateWithCertificates(type, policy, &trust)
+
+        guard let createdTrust = trust, trustCreationStatus == errSecSuccess else { return nil }
+
+        return SecTrustCopyPublicKey(createdTrust)
+    }
+}
+
+extension OSStatus: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == OSStatus {
+    /// Returns whether `self` is `errSecSuccess`.
+    public var isSuccess: Bool { type == errSecSuccess }
+}
+
+extension SecTrustResultType: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType == SecTrustResultType {
+    /// Returns whether `self is `.unspecified` or `.proceed`.
+    public var isSuccess: Bool {
+        type == .unspecified || type == .proceed
+    }
+}
+#endif

Pods/Alamofire/Source/Session.swift

@@ -0,0 +1,1258 @@
+//
+//  Session.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// `Session` creates and manages Alamofire's `Request` types during their lifetimes. It also provides common
+/// functionality for all `Request`s, including queuing, interception, trust management, redirect handling, and response
+/// cache handling.
+open class Session {
+    /// Shared singleton instance used by all `AF.request` APIs. Cannot be modified.
+    public static let `default` = Session()
+
+    /// Underlying `URLSession` used to create `URLSessionTasks` for this instance, and for which this instance's
+    /// `delegate` handles `URLSessionDelegate` callbacks.
+    ///
+    /// - Note: This instance should **NOT** be used to interact with the underlying `URLSessionTask`s. Doing so will
+    ///         break internal Alamofire logic that tracks those tasks.
+    ///
+    public let session: URLSession
+    /// Instance's `SessionDelegate`, which handles the `URLSessionDelegate` methods and `Request` interaction.
+    public let delegate: SessionDelegate
+    /// Root `DispatchQueue` for all internal callbacks and state update. **MUST** be a serial queue.
+    public let rootQueue: DispatchQueue
+    /// Value determining whether this instance automatically calls `resume()` on all created `Request`s.
+    public let startRequestsImmediately: Bool
+    /// `DispatchQueue` on which `URLRequest`s are created asynchronously. By default this queue uses `rootQueue` as its
+    /// `target`, but a separate queue can be used if request creation is determined to be a bottleneck. Always profile
+    /// and test before introducing an additional queue.
+    public let requestQueue: DispatchQueue
+    /// `DispatchQueue` passed to all `Request`s on which they perform their response serialization. By default this
+    /// queue uses `rootQueue` as its `target` but a separate queue can be used if response serialization is determined
+    /// to be a bottleneck. Always profile and test before introducing an additional queue.
+    public let serializationQueue: DispatchQueue
+    /// `RequestInterceptor` used for all `Request` created by the instance. `RequestInterceptor`s can also be set on a
+    /// per-`Request` basis, in which case the `Request`'s interceptor takes precedence over this value.
+    public let interceptor: RequestInterceptor?
+    /// `ServerTrustManager` instance used to evaluate all trust challenges and provide certificate and key pinning.
+    public let serverTrustManager: ServerTrustManager?
+    /// `RedirectHandler` instance used to provide customization for request redirection.
+    public let redirectHandler: RedirectHandler?
+    /// `CachedResponseHandler` instance used to provide customization of cached response handling.
+    public let cachedResponseHandler: CachedResponseHandler?
+    /// `CompositeEventMonitor` used to compose Alamofire's `defaultEventMonitors` and any passed `EventMonitor`s.
+    public let eventMonitor: CompositeEventMonitor
+    /// `EventMonitor`s included in all instances. `[AlamofireNotifications()]` by default.
+    public let defaultEventMonitors: [EventMonitor] = [AlamofireNotifications()]
+
+    /// Internal map between `Request`s and any `URLSessionTasks` that may be in flight for them.
+    var requestTaskMap = RequestTaskMap()
+    /// `Set` of currently active `Request`s.
+    var activeRequests: Set<Request> = []
+    /// Completion events awaiting `URLSessionTaskMetrics`.
+    var waitingCompletions: [URLSessionTask: () -> Void] = [:]
+
+    /// Creates a `Session` from a `URLSession` and other parameters.
+    ///
+    /// - Note: When passing a `URLSession`, you must create the `URLSession` with a specific `delegateQueue` value and
+    ///         pass the `delegateQueue`'s `underlyingQueue` as the `rootQueue` parameter of this initializer.
+    ///
+    /// - Parameters:
+    ///   - session:                  Underlying `URLSession` for this instance.
+    ///   - delegate:                 `SessionDelegate` that handles `session`'s delegate callbacks as well as `Request`
+    ///                               interaction.
+    ///   - rootQueue:                Root `DispatchQueue` for all internal callbacks and state updates. **MUST** be a
+    ///                               serial queue.
+    ///   - startRequestsImmediately: Determines whether this instance will automatically start all `Request`s. `true`
+    ///                               by default. If set to `false`, all `Request`s created must have `.resume()` called.
+    ///                               on them for them to start.
+    ///   - requestQueue:             `DispatchQueue` on which to perform `URLRequest` creation. By default this queue
+    ///                               will use the `rootQueue` as its `target`. A separate queue can be used if it's
+    ///                               determined request creation is a bottleneck, but that should only be done after
+    ///                               careful testing and profiling. `nil` by default.
+    ///   - serializationQueue:       `DispatchQueue` on which to perform all response serialization. By default this
+    ///                               queue will use the `rootQueue` as its `target`. A separate queue can be used if
+    ///                               it's determined response serialization is a bottleneck, but that should only be
+    ///                               done after careful testing and profiling. `nil` by default.
+    ///   - interceptor:              `RequestInterceptor` to be used for all `Request`s created by this instance. `nil`
+    ///                               by default.
+    ///   - serverTrustManager:       `ServerTrustManager` to be used for all trust evaluations by this instance. `nil`
+    ///                               by default.
+    ///   - redirectHandler:          `RedirectHandler` to be used by all `Request`s created by this instance. `nil` by
+    ///                               default.
+    ///   - cachedResponseHandler:    `CachedResponseHandler` to be used by all `Request`s created by this instance.
+    ///                               `nil` by default.
+    ///   - eventMonitors:            Additional `EventMonitor`s used by the instance. Alamofire always adds a
+    ///                               `AlamofireNotifications` `EventMonitor` to the array passed here. `[]` by default.
+    public init(session: URLSession,
+                delegate: SessionDelegate,
+                rootQueue: DispatchQueue,
+                startRequestsImmediately: Bool = true,
+                requestQueue: DispatchQueue? = nil,
+                serializationQueue: DispatchQueue? = nil,
+                interceptor: RequestInterceptor? = nil,
+                serverTrustManager: ServerTrustManager? = nil,
+                redirectHandler: RedirectHandler? = nil,
+                cachedResponseHandler: CachedResponseHandler? = nil,
+                eventMonitors: [EventMonitor] = []) {
+        precondition(session.configuration.identifier == nil,
+                     "Alamofire does not support background URLSessionConfigurations.")
+        precondition(session.delegateQueue.underlyingQueue === rootQueue,
+                     "Session(session:) initializer must be passed the DispatchQueue used as the delegateQueue's underlyingQueue as rootQueue.")
+
+        self.session = session
+        self.delegate = delegate
+        self.rootQueue = rootQueue
+        self.startRequestsImmediately = startRequestsImmediately
+        self.requestQueue = requestQueue ?? DispatchQueue(label: "\(rootQueue.label).requestQueue", target: rootQueue)
+        self.serializationQueue = serializationQueue ?? DispatchQueue(label: "\(rootQueue.label).serializationQueue", target: rootQueue)
+        self.interceptor = interceptor
+        self.serverTrustManager = serverTrustManager
+        self.redirectHandler = redirectHandler
+        self.cachedResponseHandler = cachedResponseHandler
+        eventMonitor = CompositeEventMonitor(monitors: defaultEventMonitors + eventMonitors)
+        delegate.eventMonitor = eventMonitor
+        delegate.stateProvider = self
+    }
+
+    /// Creates a `Session` from a `URLSessionConfiguration`.
+    ///
+    /// - Note: This initializer lets Alamofire handle the creation of the underlying `URLSession` and its
+    ///         `delegateQueue`, and is the recommended initializer for most uses.
+    ///
+    /// - Parameters:
+    ///   - configuration:            `URLSessionConfiguration` to be used to create the underlying `URLSession`. Changes
+    ///                               to this value after being passed to this initializer will have no effect.
+    ///                               `URLSessionConfiguration.af.default` by default.
+    ///   - delegate:                 `SessionDelegate` that handles `session`'s delegate callbacks as well as `Request`
+    ///                               interaction. `SessionDelegate()` by default.
+    ///   - rootQueue:                Root `DispatchQueue` for all internal callbacks and state updates. **MUST** be a
+    ///                               serial queue. `DispatchQueue(label: "org.alamofire.session.rootQueue")` by default.
+    ///   - startRequestsImmediately: Determines whether this instance will automatically start all `Request`s. `true`
+    ///                               by default. If set to `false`, all `Request`s created must have `.resume()` called.
+    ///                               on them for them to start.
+    ///   - requestQueue:             `DispatchQueue` on which to perform `URLRequest` creation. By default this queue
+    ///                               will use the `rootQueue` as its `target`. A separate queue can be used if it's
+    ///                               determined request creation is a bottleneck, but that should only be done after
+    ///                               careful testing and profiling. `nil` by default.
+    ///   - serializationQueue:       `DispatchQueue` on which to perform all response serialization. By default this
+    ///                               queue will use the `rootQueue` as its `target`. A separate queue can be used if
+    ///                               it's determined response serialization is a bottleneck, but that should only be
+    ///                               done after careful testing and profiling. `nil` by default.
+    ///   - interceptor:              `RequestInterceptor` to be used for all `Request`s created by this instance. `nil`
+    ///                               by default.
+    ///   - serverTrustManager:       `ServerTrustManager` to be used for all trust evaluations by this instance. `nil`
+    ///                               by default.
+    ///   - redirectHandler:          `RedirectHandler` to be used by all `Request`s created by this instance. `nil` by
+    ///                               default.
+    ///   - cachedResponseHandler:    `CachedResponseHandler` to be used by all `Request`s created by this instance.
+    ///                               `nil` by default.
+    ///   - eventMonitors:            Additional `EventMonitor`s used by the instance. Alamofire always adds a
+    ///                               `AlamofireNotifications` `EventMonitor` to the array passed here. `[]` by default.
+    public convenience init(configuration: URLSessionConfiguration = URLSessionConfiguration.af.default,
+                            delegate: SessionDelegate = SessionDelegate(),
+                            rootQueue: DispatchQueue = DispatchQueue(label: "org.alamofire.session.rootQueue"),
+                            startRequestsImmediately: Bool = true,
+                            requestQueue: DispatchQueue? = nil,
+                            serializationQueue: DispatchQueue? = nil,
+                            interceptor: RequestInterceptor? = nil,
+                            serverTrustManager: ServerTrustManager? = nil,
+                            redirectHandler: RedirectHandler? = nil,
+                            cachedResponseHandler: CachedResponseHandler? = nil,
+                            eventMonitors: [EventMonitor] = []) {
+        precondition(configuration.identifier == nil, "Alamofire does not support background URLSessionConfigurations.")
+
+        let delegateQueue = OperationQueue(maxConcurrentOperationCount: 1, underlyingQueue: rootQueue, name: "org.alamofire.session.sessionDelegateQueue")
+        let session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: delegateQueue)
+
+        self.init(session: session,
+                  delegate: delegate,
+                  rootQueue: rootQueue,
+                  startRequestsImmediately: startRequestsImmediately,
+                  requestQueue: requestQueue,
+                  serializationQueue: serializationQueue,
+                  interceptor: interceptor,
+                  serverTrustManager: serverTrustManager,
+                  redirectHandler: redirectHandler,
+                  cachedResponseHandler: cachedResponseHandler,
+                  eventMonitors: eventMonitors)
+    }
+
+    deinit {
+        finishRequestsForDeinit()
+        session.invalidateAndCancel()
+    }
+
+    // MARK: - All Requests API
+
+    /// Perform an action on all active `Request`s.
+    ///
+    /// - Note: The provided `action` closure is performed asynchronously, meaning that some `Request`s may complete and
+    ///         be unavailable by time it runs. Additionally, this action is performed on the instances's `rootQueue`,
+    ///         so care should be taken that actions are fast. Once the work on the `Request`s is complete, any
+    ///         additional work should be performed on another queue.
+    ///
+    /// - Parameters:
+    ///   - action:     Closure to perform with all `Request`s.
+    public func withAllRequests(perform action: @escaping (Set<Request>) -> Void) {
+        rootQueue.async {
+            action(self.activeRequests)
+        }
+    }
+
+    /// Cancel all active `Request`s, optionally calling a completion handler when complete.
+    ///
+    /// - Note: This is an asynchronous operation and does not block the creation of future `Request`s. Cancelled
+    ///         `Request`s may not cancel immediately due internal work, and may not cancel at all if they are close to
+    ///         completion when cancelled.
+    ///
+    /// - Parameters:
+    ///   - queue:      `DispatchQueue` on which the completion handler is run. `.main` by default.
+    ///   - completion: Closure to be called when all `Request`s have been cancelled.
+    public func cancelAllRequests(completingOnQueue queue: DispatchQueue = .main, completion: (() -> Void)? = nil) {
+        withAllRequests { requests in
+            requests.forEach { $0.cancel() }
+            queue.async {
+                completion?()
+            }
+        }
+    }
+
+    // MARK: - DataRequest
+
+    /// Closure which provides a `URLRequest` for mutation.
+    public typealias RequestModifier = (inout URLRequest) throws -> Void
+
+    struct RequestConvertible: URLRequestConvertible {
+        let url: URLConvertible
+        let method: HTTPMethod
+        let parameters: Parameters?
+        let encoding: ParameterEncoding
+        let headers: HTTPHeaders?
+        let requestModifier: RequestModifier?
+
+        func asURLRequest() throws -> URLRequest {
+            var request = try URLRequest(url: url, method: method, headers: headers)
+            try requestModifier?(&request)
+
+            return try encoding.encode(request, with: parameters)
+        }
+    }
+
+    /// Creates a `DataRequest` from a `URLRequest` created using the passed components and a `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - parameters:      `Parameters` (a.k.a. `[String: Any]`) value to be encoded into the `URLRequest`. `nil` by
+    ///                      default.
+    ///   - encoding:        `ParameterEncoding` to be used to encode the `parameters` value into the `URLRequest`.
+    ///                      `URLEncoding.default` by default.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///
+    /// - Returns:       The created `DataRequest`.
+    open func request(_ convertible: URLConvertible,
+                      method: HTTPMethod = .get,
+                      parameters: Parameters? = nil,
+                      encoding: ParameterEncoding = URLEncoding.default,
+                      headers: HTTPHeaders? = nil,
+                      interceptor: RequestInterceptor? = nil,
+                      requestModifier: RequestModifier? = nil) -> DataRequest {
+        let convertible = RequestConvertible(url: convertible,
+                                             method: method,
+                                             parameters: parameters,
+                                             encoding: encoding,
+                                             headers: headers,
+                                             requestModifier: requestModifier)
+
+        return request(convertible, interceptor: interceptor)
+    }
+
+    struct RequestEncodableConvertible<Parameters: Encodable>: URLRequestConvertible {
+        let url: URLConvertible
+        let method: HTTPMethod
+        let parameters: Parameters?
+        let encoder: ParameterEncoder
+        let headers: HTTPHeaders?
+        let requestModifier: RequestModifier?
+
+        func asURLRequest() throws -> URLRequest {
+            var request = try URLRequest(url: url, method: method, headers: headers)
+            try requestModifier?(&request)
+
+            return try parameters.map { try encoder.encode($0, into: request) } ?? request
+        }
+    }
+
+    /// Creates a `DataRequest` from a `URLRequest` created using the passed components, `Encodable` parameters, and a
+    /// `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible: `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:      `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - parameters:  `Encodable` value to be encoded into the `URLRequest`. `nil` by default.
+    ///   - encoder:     `ParameterEncoder` to be used to encode the `parameters` value into the `URLRequest`.
+    ///                  `URLEncodedFormParameterEncoder.default` by default.
+    ///   - headers:     `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///
+    /// - Returns:       The created `DataRequest`.
+    open func request<Parameters: Encodable>(_ convertible: URLConvertible,
+                                             method: HTTPMethod = .get,
+                                             parameters: Parameters? = nil,
+                                             encoder: ParameterEncoder = URLEncodedFormParameterEncoder.default,
+                                             headers: HTTPHeaders? = nil,
+                                             interceptor: RequestInterceptor? = nil,
+                                             requestModifier: RequestModifier? = nil) -> DataRequest {
+        let convertible = RequestEncodableConvertible(url: convertible,
+                                                      method: method,
+                                                      parameters: parameters,
+                                                      encoder: encoder,
+                                                      headers: headers,
+                                                      requestModifier: requestModifier)
+
+        return request(convertible, interceptor: interceptor)
+    }
+
+    /// Creates a `DataRequest` from a `URLRequestConvertible` value and a `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible: `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///
+    /// - Returns:       The created `DataRequest`.
+    open func request(_ convertible: URLRequestConvertible, interceptor: RequestInterceptor? = nil) -> DataRequest {
+        let request = DataRequest(convertible: convertible,
+                                  underlyingQueue: rootQueue,
+                                  serializationQueue: serializationQueue,
+                                  eventMonitor: eventMonitor,
+                                  interceptor: interceptor,
+                                  delegate: self)
+
+        perform(request)
+
+        return request
+    }
+
+    // MARK: - DataStreamRequest
+
+    /// Creates a `DataStreamRequest` from the passed components, `Encodable` parameters, and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible:                      `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:                           `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - parameters:                       `Encodable` value to be encoded into the `URLRequest`. `nil` by default.
+    ///   - encoder:                          `ParameterEncoder` to be used to encode the `parameters` value into the
+    ///                                       `URLRequest`.
+    ///                                       `URLEncodedFormParameterEncoder.default` by default.
+    ///   - headers:                          `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - automaticallyCancelOnStreamError: `Bool` indicating whether the instance should be canceled when an `Error`
+    ///                                       is thrown while serializing stream `Data`. `false` by default.
+    ///   - interceptor:                      `RequestInterceptor` value to be used by the returned `DataRequest`. `nil`
+    ///                                       by default.
+    ///   - requestModifier:                  `RequestModifier` which will be applied to the `URLRequest` created from
+    ///                                       the provided parameters. `nil` by default.
+    ///
+    /// - Returns:       The created `DataStream` request.
+    open func streamRequest<Parameters: Encodable>(_ convertible: URLConvertible,
+                                                   method: HTTPMethod = .get,
+                                                   parameters: Parameters? = nil,
+                                                   encoder: ParameterEncoder = URLEncodedFormParameterEncoder.default,
+                                                   headers: HTTPHeaders? = nil,
+                                                   automaticallyCancelOnStreamError: Bool = false,
+                                                   interceptor: RequestInterceptor? = nil,
+                                                   requestModifier: RequestModifier? = nil) -> DataStreamRequest {
+        let convertible = RequestEncodableConvertible(url: convertible,
+                                                      method: method,
+                                                      parameters: parameters,
+                                                      encoder: encoder,
+                                                      headers: headers,
+                                                      requestModifier: requestModifier)
+
+        return streamRequest(convertible,
+                             automaticallyCancelOnStreamError: automaticallyCancelOnStreamError,
+                             interceptor: interceptor)
+    }
+
+    /// Creates a `DataStreamRequest` from the passed components and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible:                      `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:                           `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - headers:                          `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - automaticallyCancelOnStreamError: `Bool` indicating whether the instance should be canceled when an `Error`
+    ///                                       is thrown while serializing stream `Data`. `false` by default.
+    ///   - interceptor:                      `RequestInterceptor` value to be used by the returned `DataRequest`. `nil`
+    ///                                       by default.
+    ///   - requestModifier:                  `RequestModifier` which will be applied to the `URLRequest` created from
+    ///                                       the provided parameters. `nil` by default.
+    ///
+    /// - Returns:       The created `DataStream` request.
+    open func streamRequest(_ convertible: URLConvertible,
+                            method: HTTPMethod = .get,
+                            headers: HTTPHeaders? = nil,
+                            automaticallyCancelOnStreamError: Bool = false,
+                            interceptor: RequestInterceptor? = nil,
+                            requestModifier: RequestModifier? = nil) -> DataStreamRequest {
+        let convertible = RequestEncodableConvertible(url: convertible,
+                                                      method: method,
+                                                      parameters: Empty?.none,
+                                                      encoder: URLEncodedFormParameterEncoder.default,
+                                                      headers: headers,
+                                                      requestModifier: requestModifier)
+
+        return streamRequest(convertible,
+                             automaticallyCancelOnStreamError: automaticallyCancelOnStreamError,
+                             interceptor: interceptor)
+    }
+
+    /// Creates a `DataStreamRequest` from the passed `URLRequestConvertible` value and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible:                      `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - automaticallyCancelOnStreamError: `Bool` indicating whether the instance should be canceled when an `Error`
+    ///                                       is thrown while serializing stream `Data`. `false` by default.
+    ///   - interceptor:                      `RequestInterceptor` value to be used by the returned `DataRequest`. `nil`
+    ///                                        by default.
+    ///
+    /// - Returns:       The created `DataStreamRequest`.
+    open func streamRequest(_ convertible: URLRequestConvertible,
+                            automaticallyCancelOnStreamError: Bool = false,
+                            interceptor: RequestInterceptor? = nil) -> DataStreamRequest {
+        let request = DataStreamRequest(convertible: convertible,
+                                        automaticallyCancelOnStreamError: automaticallyCancelOnStreamError,
+                                        underlyingQueue: rootQueue,
+                                        serializationQueue: serializationQueue,
+                                        eventMonitor: eventMonitor,
+                                        interceptor: interceptor,
+                                        delegate: self)
+
+        perform(request)
+
+        return request
+    }
+
+    // MARK: - DownloadRequest
+
+    /// Creates a `DownloadRequest` using a `URLRequest` created using the passed components, `RequestInterceptor`, and
+    /// `Destination`.
+    ///
+    /// - Parameters:
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - parameters:      `Parameters` (a.k.a. `[String: Any]`) value to be encoded into the `URLRequest`. `nil` by
+    ///                      default.
+    ///   - encoding:        `ParameterEncoding` to be used to encode the `parameters` value into the `URLRequest`.
+    ///                      Defaults to `URLEncoding.default`.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///   - destination:     `DownloadRequest.Destination` closure used to determine how and where the downloaded file
+    ///                      should be moved. `nil` by default.
+    ///
+    /// - Returns:           The created `DownloadRequest`.
+    open func download(_ convertible: URLConvertible,
+                       method: HTTPMethod = .get,
+                       parameters: Parameters? = nil,
+                       encoding: ParameterEncoding = URLEncoding.default,
+                       headers: HTTPHeaders? = nil,
+                       interceptor: RequestInterceptor? = nil,
+                       requestModifier: RequestModifier? = nil,
+                       to destination: DownloadRequest.Destination? = nil) -> DownloadRequest {
+        let convertible = RequestConvertible(url: convertible,
+                                             method: method,
+                                             parameters: parameters,
+                                             encoding: encoding,
+                                             headers: headers,
+                                             requestModifier: requestModifier)
+
+        return download(convertible, interceptor: interceptor, to: destination)
+    }
+
+    /// Creates a `DownloadRequest` from a `URLRequest` created using the passed components, `Encodable` parameters, and
+    /// a `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.get` by default.
+    ///   - parameters:      Value conforming to `Encodable` to be encoded into the `URLRequest`. `nil` by default.
+    ///   - encoder:         `ParameterEncoder` to be used to encode the `parameters` value into the `URLRequest`.
+    ///                      Defaults to `URLEncodedFormParameterEncoder.default`.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///   - destination:     `DownloadRequest.Destination` closure used to determine how and where the downloaded file
+    ///                      should be moved. `nil` by default.
+    ///
+    /// - Returns:           The created `DownloadRequest`.
+    open func download<Parameters: Encodable>(_ convertible: URLConvertible,
+                                              method: HTTPMethod = .get,
+                                              parameters: Parameters? = nil,
+                                              encoder: ParameterEncoder = URLEncodedFormParameterEncoder.default,
+                                              headers: HTTPHeaders? = nil,
+                                              interceptor: RequestInterceptor? = nil,
+                                              requestModifier: RequestModifier? = nil,
+                                              to destination: DownloadRequest.Destination? = nil) -> DownloadRequest {
+        let convertible = RequestEncodableConvertible(url: convertible,
+                                                      method: method,
+                                                      parameters: parameters,
+                                                      encoder: encoder,
+                                                      headers: headers,
+                                                      requestModifier: requestModifier)
+
+        return download(convertible, interceptor: interceptor, to: destination)
+    }
+
+    /// Creates a `DownloadRequest` from a `URLRequestConvertible` value, a `RequestInterceptor`, and a `Destination`.
+    ///
+    /// - Parameters:
+    ///   - convertible: `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - destination: `DownloadRequest.Destination` closure used to determine how and where the downloaded file
+    ///                  should be moved. `nil` by default.
+    ///
+    /// - Returns:       The created `DownloadRequest`.
+    open func download(_ convertible: URLRequestConvertible,
+                       interceptor: RequestInterceptor? = nil,
+                       to destination: DownloadRequest.Destination? = nil) -> DownloadRequest {
+        let request = DownloadRequest(downloadable: .request(convertible),
+                                      underlyingQueue: rootQueue,
+                                      serializationQueue: serializationQueue,
+                                      eventMonitor: eventMonitor,
+                                      interceptor: interceptor,
+                                      delegate: self,
+                                      destination: destination ?? DownloadRequest.defaultDestination)
+
+        perform(request)
+
+        return request
+    }
+
+    /// Creates a `DownloadRequest` from the `resumeData` produced from a previously cancelled `DownloadRequest`, as
+    /// well as a `RequestInterceptor`, and a `Destination`.
+    ///
+    /// - Note: If `destination` is not specified, the download will be moved to a temporary location determined by
+    ///         Alamofire. The file will not be deleted until the system purges the temporary files.
+    ///
+    /// - Note: On some versions of all Apple platforms (iOS 10 - 10.2, macOS 10.12 - 10.12.2, tvOS 10 - 10.1, watchOS 3 - 3.1.1),
+    /// `resumeData` is broken on background URL session configurations. There's an underlying bug in the `resumeData`
+    /// generation logic where the data is written incorrectly and will always fail to resume the download. For more
+    /// information about the bug and possible workarounds, please refer to the [this Stack Overflow post](http://stackoverflow.com/a/39347461/1342462).
+    ///
+    /// - Parameters:
+    ///   - data:        The resume data from a previously cancelled `DownloadRequest` or `URLSessionDownloadTask`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - destination: `DownloadRequest.Destination` closure used to determine how and where the downloaded file
+    ///                  should be moved. `nil` by default.
+    ///
+    /// - Returns:       The created `DownloadRequest`.
+    open func download(resumingWith data: Data,
+                       interceptor: RequestInterceptor? = nil,
+                       to destination: DownloadRequest.Destination? = nil) -> DownloadRequest {
+        let request = DownloadRequest(downloadable: .resumeData(data),
+                                      underlyingQueue: rootQueue,
+                                      serializationQueue: serializationQueue,
+                                      eventMonitor: eventMonitor,
+                                      interceptor: interceptor,
+                                      delegate: self,
+                                      destination: destination ?? DownloadRequest.defaultDestination)
+
+        perform(request)
+
+        return request
+    }
+
+    // MARK: - UploadRequest
+
+    struct ParameterlessRequestConvertible: URLRequestConvertible {
+        let url: URLConvertible
+        let method: HTTPMethod
+        let headers: HTTPHeaders?
+        let requestModifier: RequestModifier?
+
+        func asURLRequest() throws -> URLRequest {
+            var request = try URLRequest(url: url, method: method, headers: headers)
+            try requestModifier?(&request)
+
+            return request
+        }
+    }
+
+    struct Upload: UploadConvertible {
+        let request: URLRequestConvertible
+        let uploadable: UploadableConvertible
+
+        func createUploadable() throws -> UploadRequest.Uploadable {
+            try uploadable.createUploadable()
+        }
+
+        func asURLRequest() throws -> URLRequest {
+            try request.asURLRequest()
+        }
+    }
+
+    // MARK: Data
+
+    /// Creates an `UploadRequest` for the given `Data`, `URLRequest` components, and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - data:            The `Data` to upload.
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.post` by default.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:     `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                      default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///
+    /// - Returns:           The created `UploadRequest`.
+    open func upload(_ data: Data,
+                     to convertible: URLConvertible,
+                     method: HTTPMethod = .post,
+                     headers: HTTPHeaders? = nil,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default,
+                     requestModifier: RequestModifier? = nil) -> UploadRequest {
+        let convertible = ParameterlessRequestConvertible(url: convertible,
+                                                          method: method,
+                                                          headers: headers,
+                                                          requestModifier: requestModifier)
+
+        return upload(data, with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` for the given `Data` using the `URLRequestConvertible` value and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - data:        The `Data` to upload.
+    ///   - convertible: `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager: `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                  default.
+    ///
+    /// - Returns:       The created `UploadRequest`.
+    open func upload(_ data: Data,
+                     with convertible: URLRequestConvertible,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default) -> UploadRequest {
+        upload(.data(data), with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    // MARK: File
+
+    /// Creates an `UploadRequest` for the file at the given file `URL`, using a `URLRequest` from the provided
+    /// components and `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - fileURL:         The `URL` of the file to upload.
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.post` by default.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `UploadRequest`. `nil` by default.
+    ///   - fileManager:     `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                      default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///
+    /// - Returns:           The created `UploadRequest`.
+    open func upload(_ fileURL: URL,
+                     to convertible: URLConvertible,
+                     method: HTTPMethod = .post,
+                     headers: HTTPHeaders? = nil,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default,
+                     requestModifier: RequestModifier? = nil) -> UploadRequest {
+        let convertible = ParameterlessRequestConvertible(url: convertible,
+                                                          method: method,
+                                                          headers: headers,
+                                                          requestModifier: requestModifier)
+
+        return upload(fileURL, with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` for the file at the given file `URL` using the `URLRequestConvertible` value and
+    /// `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - fileURL:     The `URL` of the file to upload.
+    ///   - convertible: `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager: `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                  default.
+    ///
+    /// - Returns:       The created `UploadRequest`.
+    open func upload(_ fileURL: URL,
+                     with convertible: URLRequestConvertible,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default) -> UploadRequest {
+        upload(.file(fileURL, shouldRemove: false), with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    // MARK: InputStream
+
+    /// Creates an `UploadRequest` from the `InputStream` provided using a `URLRequest` from the provided components and
+    /// `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - stream:          The `InputStream` that provides the data to upload.
+    ///   - convertible:     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - method:          `HTTPMethod` for the `URLRequest`. `.post` by default.
+    ///   - headers:         `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:     `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:     `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                      default.
+    ///   - requestModifier: `RequestModifier` which will be applied to the `URLRequest` created from the provided
+    ///                      parameters. `nil` by default.
+    ///
+    /// - Returns:           The created `UploadRequest`.
+    open func upload(_ stream: InputStream,
+                     to convertible: URLConvertible,
+                     method: HTTPMethod = .post,
+                     headers: HTTPHeaders? = nil,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default,
+                     requestModifier: RequestModifier? = nil) -> UploadRequest {
+        let convertible = ParameterlessRequestConvertible(url: convertible,
+                                                          method: method,
+                                                          headers: headers,
+                                                          requestModifier: requestModifier)
+
+        return upload(stream, with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` from the provided `InputStream` using the `URLRequestConvertible` value and
+    /// `RequestInterceptor`.
+    ///
+    /// - Parameters:
+    ///   - stream:      The `InputStream` that provides the data to upload.
+    ///   - convertible: `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - interceptor: `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager: `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                  default.
+    ///
+    /// - Returns:       The created `UploadRequest`.
+    open func upload(_ stream: InputStream,
+                     with convertible: URLRequestConvertible,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default) -> UploadRequest {
+        upload(.stream(stream), with: convertible, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    // MARK: MultipartFormData
+
+    /// Creates an `UploadRequest` for the multipart form data built using a closure and sent using the provided
+    /// `URLRequest` components and `RequestInterceptor`.
+    ///
+    /// It is important to understand the memory implications of uploading `MultipartFormData`. If the cumulative
+    /// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
+    /// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
+    /// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
+    /// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
+    /// used for larger payloads such as video content.
+    ///
+    /// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
+    /// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
+    /// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
+    /// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
+    /// technique was used.
+    ///
+    /// - Parameters:
+    ///   - multipartFormData:       `MultipartFormData` building closure.
+    ///   - convertible:             `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - encodingMemoryThreshold: Byte threshold used to determine whether the form data is encoded into memory or
+    ///                              onto disk before being uploaded. `MultipartFormData.encodingMemoryThreshold` by
+    ///                              default.
+    ///   - method:                  `HTTPMethod` for the `URLRequest`. `.post` by default.
+    ///   - headers:                 `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:             `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:             `FileManager` to be used if the form data exceeds the memory threshold and is
+    ///                              written to disk before being uploaded. `.default` instance by default.
+    ///   - requestModifier:         `RequestModifier` which will be applied to the `URLRequest` created from the
+    ///                              provided parameters. `nil` by default.
+    ///
+    /// - Returns:                   The created `UploadRequest`.
+    open func upload(multipartFormData: @escaping (MultipartFormData) -> Void,
+                     to url: URLConvertible,
+                     usingThreshold encodingMemoryThreshold: UInt64 = MultipartFormData.encodingMemoryThreshold,
+                     method: HTTPMethod = .post,
+                     headers: HTTPHeaders? = nil,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default,
+                     requestModifier: RequestModifier? = nil) -> UploadRequest {
+        let convertible = ParameterlessRequestConvertible(url: url,
+                                                          method: method,
+                                                          headers: headers,
+                                                          requestModifier: requestModifier)
+
+        let formData = MultipartFormData(fileManager: fileManager)
+        multipartFormData(formData)
+
+        return upload(multipartFormData: formData,
+                      with: convertible,
+                      usingThreshold: encodingMemoryThreshold,
+                      interceptor: interceptor,
+                      fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` using a `MultipartFormData` building closure, the provided `URLRequestConvertible`
+    /// value, and a `RequestInterceptor`.
+    ///
+    /// It is important to understand the memory implications of uploading `MultipartFormData`. If the cumulative
+    /// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
+    /// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
+    /// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
+    /// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
+    /// used for larger payloads such as video content.
+    ///
+    /// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
+    /// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
+    /// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
+    /// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
+    /// technique was used.
+    ///
+    /// - Parameters:
+    ///   - multipartFormData:       `MultipartFormData` building closure.
+    ///   - request:                 `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - encodingMemoryThreshold: Byte threshold used to determine whether the form data is encoded into memory or
+    ///                              onto disk before being uploaded. `MultipartFormData.encodingMemoryThreshold` by
+    ///                              default.
+    ///   - interceptor:             `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:             `FileManager` to be used if the form data exceeds the memory threshold and is
+    ///                              written to disk before being uploaded. `.default` instance by default.
+    ///
+    /// - Returns:                   The created `UploadRequest`.
+    open func upload(multipartFormData: @escaping (MultipartFormData) -> Void,
+                     with request: URLRequestConvertible,
+                     usingThreshold encodingMemoryThreshold: UInt64 = MultipartFormData.encodingMemoryThreshold,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default) -> UploadRequest {
+        let formData = MultipartFormData(fileManager: fileManager)
+        multipartFormData(formData)
+
+        return upload(multipartFormData: formData,
+                      with: request,
+                      usingThreshold: encodingMemoryThreshold,
+                      interceptor: interceptor,
+                      fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` for the prebuilt `MultipartFormData` value using the provided `URLRequest` components
+    /// and `RequestInterceptor`.
+    ///
+    /// It is important to understand the memory implications of uploading `MultipartFormData`. If the cumulative
+    /// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
+    /// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
+    /// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
+    /// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
+    /// used for larger payloads such as video content.
+    ///
+    /// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
+    /// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
+    /// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
+    /// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
+    /// technique was used.
+    ///
+    /// - Parameters:
+    ///   - multipartFormData:       `MultipartFormData` instance to upload.
+    ///   - url:                     `URLConvertible` value to be used as the `URLRequest`'s `URL`.
+    ///   - encodingMemoryThreshold: Byte threshold used to determine whether the form data is encoded into memory or
+    ///                              onto disk before being uploaded. `MultipartFormData.encodingMemoryThreshold` by
+    ///                              default.
+    ///   - method:                  `HTTPMethod` for the `URLRequest`. `.post` by default.
+    ///   - headers:                 `HTTPHeaders` value to be added to the `URLRequest`. `nil` by default.
+    ///   - interceptor:             `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:             `FileManager` to be used if the form data exceeds the memory threshold and is
+    ///                              written to disk before being uploaded. `.default` instance by default.
+    ///   - requestModifier:         `RequestModifier` which will be applied to the `URLRequest` created from the
+    ///                              provided parameters. `nil` by default.
+    ///
+    /// - Returns:                   The created `UploadRequest`.
+    open func upload(multipartFormData: MultipartFormData,
+                     to url: URLConvertible,
+                     usingThreshold encodingMemoryThreshold: UInt64 = MultipartFormData.encodingMemoryThreshold,
+                     method: HTTPMethod = .post,
+                     headers: HTTPHeaders? = nil,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default,
+                     requestModifier: RequestModifier? = nil) -> UploadRequest {
+        let convertible = ParameterlessRequestConvertible(url: url,
+                                                          method: method,
+                                                          headers: headers,
+                                                          requestModifier: requestModifier)
+
+        let multipartUpload = MultipartUpload(encodingMemoryThreshold: encodingMemoryThreshold,
+                                              request: convertible,
+                                              multipartFormData: multipartFormData)
+
+        return upload(multipartUpload, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    /// Creates an `UploadRequest` for the prebuilt `MultipartFormData` value using the providing `URLRequestConvertible`
+    /// value and `RequestInterceptor`.
+    ///
+    /// It is important to understand the memory implications of uploading `MultipartFormData`. If the cumulative
+    /// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
+    /// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
+    /// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
+    /// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
+    /// used for larger payloads such as video content.
+    ///
+    /// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
+    /// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
+    /// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
+    /// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
+    /// technique was used.
+    ///
+    /// - Parameters:
+    ///   - multipartFormData:       `MultipartFormData` instance to upload.
+    ///   - request:                 `URLRequestConvertible` value to be used to create the `URLRequest`.
+    ///   - encodingMemoryThreshold: Byte threshold used to determine whether the form data is encoded into memory or
+    ///                              onto disk before being uploaded. `MultipartFormData.encodingMemoryThreshold` by
+    ///                              default.
+    ///   - interceptor:             `RequestInterceptor` value to be used by the returned `DataRequest`. `nil` by default.
+    ///   - fileManager:             `FileManager` instance to be used by the returned `UploadRequest`. `.default` instance by
+    ///                              default.
+    ///
+    /// - Returns:                   The created `UploadRequest`.
+    open func upload(multipartFormData: MultipartFormData,
+                     with request: URLRequestConvertible,
+                     usingThreshold encodingMemoryThreshold: UInt64 = MultipartFormData.encodingMemoryThreshold,
+                     interceptor: RequestInterceptor? = nil,
+                     fileManager: FileManager = .default) -> UploadRequest {
+        let multipartUpload = MultipartUpload(encodingMemoryThreshold: encodingMemoryThreshold,
+                                              request: request,
+                                              multipartFormData: multipartFormData)
+
+        return upload(multipartUpload, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    // MARK: - Internal API
+
+    // MARK: Uploadable
+
+    func upload(_ uploadable: UploadRequest.Uploadable,
+                with convertible: URLRequestConvertible,
+                interceptor: RequestInterceptor?,
+                fileManager: FileManager) -> UploadRequest {
+        let uploadable = Upload(request: convertible, uploadable: uploadable)
+
+        return upload(uploadable, interceptor: interceptor, fileManager: fileManager)
+    }
+
+    func upload(_ upload: UploadConvertible, interceptor: RequestInterceptor?, fileManager: FileManager) -> UploadRequest {
+        let request = UploadRequest(convertible: upload,
+                                    underlyingQueue: rootQueue,
+                                    serializationQueue: serializationQueue,
+                                    eventMonitor: eventMonitor,
+                                    interceptor: interceptor,
+                                    fileManager: fileManager,
+                                    delegate: self)
+
+        perform(request)
+
+        return request
+    }
+
+    // MARK: Perform
+
+    /// Starts performing the provided `Request`.
+    ///
+    /// - Parameter request: The `Request` to perform.
+    func perform(_ request: Request) {
+        rootQueue.async {
+            guard !request.isCancelled else { return }
+
+            self.activeRequests.insert(request)
+
+            self.requestQueue.async {
+                // Leaf types must come first, otherwise they will cast as their superclass.
+                switch request {
+                case let r as UploadRequest: self.performUploadRequest(r) // UploadRequest must come before DataRequest due to subtype relationship.
+                case let r as DataRequest: self.performDataRequest(r)
+                case let r as DownloadRequest: self.performDownloadRequest(r)
+                case let r as DataStreamRequest: self.performDataStreamRequest(r)
+                default: fatalError("Attempted to perform unsupported Request subclass: \(type(of: request))")
+                }
+            }
+        }
+    }
+
+    func performDataRequest(_ request: DataRequest) {
+        dispatchPrecondition(condition: .onQueue(requestQueue))
+
+        performSetupOperations(for: request, convertible: request.convertible)
+    }
+
+    func performDataStreamRequest(_ request: DataStreamRequest) {
+        dispatchPrecondition(condition: .onQueue(requestQueue))
+
+        performSetupOperations(for: request, convertible: request.convertible)
+    }
+
+    func performUploadRequest(_ request: UploadRequest) {
+        dispatchPrecondition(condition: .onQueue(requestQueue))
+
+        performSetupOperations(for: request, convertible: request.convertible) {
+            do {
+                let uploadable = try request.upload.createUploadable()
+                self.rootQueue.async { request.didCreateUploadable(uploadable) }
+                return true
+            } catch {
+                self.rootQueue.async { request.didFailToCreateUploadable(with: error.asAFError(or: .createUploadableFailed(error: error))) }
+                return false
+            }
+        }
+    }
+
+    func performDownloadRequest(_ request: DownloadRequest) {
+        dispatchPrecondition(condition: .onQueue(requestQueue))
+
+        switch request.downloadable {
+        case let .request(convertible):
+            performSetupOperations(for: request, convertible: convertible)
+        case let .resumeData(resumeData):
+            rootQueue.async { self.didReceiveResumeData(resumeData, for: request) }
+        }
+    }
+
+    func performSetupOperations(for request: Request,
+                                convertible: URLRequestConvertible,
+                                shouldCreateTask: @escaping () -> Bool = { true })
+    {
+        dispatchPrecondition(condition: .onQueue(requestQueue))
+
+        let initialRequest: URLRequest
+
+        do {
+            initialRequest = try convertible.asURLRequest()
+            try initialRequest.validate()
+        } catch {
+            rootQueue.async { request.didFailToCreateURLRequest(with: error.asAFError(or: .createURLRequestFailed(error: error))) }
+            return
+        }
+
+        rootQueue.async { request.didCreateInitialURLRequest(initialRequest) }
+
+        guard !request.isCancelled else { return }
+
+        guard let adapter = adapter(for: request) else {
+            guard shouldCreateTask() else { return }
+            rootQueue.async { self.didCreateURLRequest(initialRequest, for: request) }
+            return
+        }
+
+        adapter.adapt(initialRequest, for: self) { result in
+            do {
+                let adaptedRequest = try result.get()
+                try adaptedRequest.validate()
+
+                self.rootQueue.async { request.didAdaptInitialRequest(initialRequest, to: adaptedRequest) }
+
+                guard shouldCreateTask() else { return }
+
+                self.rootQueue.async { self.didCreateURLRequest(adaptedRequest, for: request) }
+            } catch {
+                self.rootQueue.async { request.didFailToAdaptURLRequest(initialRequest, withError: .requestAdaptationFailed(error: error)) }
+            }
+        }
+    }
+
+    // MARK: - Task Handling
+
+    func didCreateURLRequest(_ urlRequest: URLRequest, for request: Request) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        request.didCreateURLRequest(urlRequest)
+
+        guard !request.isCancelled else { return }
+
+        let task = request.task(for: urlRequest, using: session)
+        requestTaskMap[request] = task
+        request.didCreateTask(task)
+
+        updateStatesForTask(task, request: request)
+    }
+
+    func didReceiveResumeData(_ data: Data, for request: DownloadRequest) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        guard !request.isCancelled else { return }
+
+        let task = request.task(forResumeData: data, using: session)
+        requestTaskMap[request] = task
+        request.didCreateTask(task)
+
+        updateStatesForTask(task, request: request)
+    }
+
+    func updateStatesForTask(_ task: URLSessionTask, request: Request) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        request.withState { state in
+            switch state {
+            case .initialized, .finished:
+                // Do nothing.
+                break
+            case .resumed:
+                task.resume()
+                rootQueue.async { request.didResumeTask(task) }
+            case .suspended:
+                task.suspend()
+                rootQueue.async { request.didSuspendTask(task) }
+            case .cancelled:
+                // Resume to ensure metrics are gathered.
+                task.resume()
+                task.cancel()
+                rootQueue.async { request.didCancelTask(task) }
+            }
+        }
+    }
+
+    // MARK: - Adapters and Retriers
+
+    func adapter(for request: Request) -> RequestAdapter? {
+        if let requestInterceptor = request.interceptor, let sessionInterceptor = interceptor {
+            return Interceptor(adapters: [requestInterceptor, sessionInterceptor])
+        } else {
+            return request.interceptor ?? interceptor
+        }
+    }
+
+    func retrier(for request: Request) -> RequestRetrier? {
+        if let requestInterceptor = request.interceptor, let sessionInterceptor = interceptor {
+            return Interceptor(retriers: [requestInterceptor, sessionInterceptor])
+        } else {
+            return request.interceptor ?? interceptor
+        }
+    }
+
+    // MARK: - Invalidation
+
+    func finishRequestsForDeinit() {
+        requestTaskMap.requests.forEach { request in
+            rootQueue.async {
+                request.finish(error: AFError.sessionDeinitialized)
+            }
+        }
+    }
+}
+
+// MARK: - RequestDelegate
+
+extension Session: RequestDelegate {
+    public var sessionConfiguration: URLSessionConfiguration {
+        session.configuration
+    }
+
+    public var startImmediately: Bool { startRequestsImmediately }
+
+    public func cleanup(after request: Request) {
+        activeRequests.remove(request)
+    }
+
+    public func retryResult(for request: Request, dueTo error: AFError, completion: @escaping (RetryResult) -> Void) {
+        guard let retrier = retrier(for: request) else {
+            rootQueue.async { completion(.doNotRetry) }
+            return
+        }
+
+        retrier.retry(request, for: self, dueTo: error) { retryResult in
+            self.rootQueue.async {
+                guard let retryResultError = retryResult.error else { completion(retryResult); return }
+
+                let retryError = AFError.requestRetryFailed(retryError: retryResultError, originalError: error)
+                completion(.doNotRetryWithError(retryError))
+            }
+        }
+    }
+
+    public func retryRequest(_ request: Request, withDelay timeDelay: TimeInterval?) {
+        rootQueue.async {
+            let retry: () -> Void = {
+                guard !request.isCancelled else { return }
+
+                request.prepareForRetry()
+                self.perform(request)
+            }
+
+            if let retryDelay = timeDelay {
+                self.rootQueue.after(retryDelay) { retry() }
+            } else {
+                retry()
+            }
+        }
+    }
+}
+
+// MARK: - SessionStateProvider
+
+extension Session: SessionStateProvider {
+    func request(for task: URLSessionTask) -> Request? {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        return requestTaskMap[task]
+    }
+
+    func didGatherMetricsForTask(_ task: URLSessionTask) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        let didDisassociate = requestTaskMap.disassociateIfNecessaryAfterGatheringMetricsForTask(task)
+
+        if didDisassociate {
+            waitingCompletions[task]?()
+            waitingCompletions[task] = nil
+        }
+    }
+
+    func didCompleteTask(_ task: URLSessionTask, completion: @escaping () -> Void) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        let didDisassociate = requestTaskMap.disassociateIfNecessaryAfterCompletingTask(task)
+
+        if didDisassociate {
+            completion()
+        } else {
+            waitingCompletions[task] = completion
+        }
+    }
+
+    func credential(for task: URLSessionTask, in protectionSpace: URLProtectionSpace) -> URLCredential? {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        return requestTaskMap[task]?.credential ??
+            session.configuration.urlCredentialStorage?.defaultCredential(for: protectionSpace)
+    }
+
+    func cancelRequestsForSessionInvalidation(with error: Error?) {
+        dispatchPrecondition(condition: .onQueue(rootQueue))
+
+        requestTaskMap.requests.forEach { $0.finish(error: AFError.sessionInvalidated(error: error)) }
+    }
+}

Pods/Alamofire/Source/SessionDelegate.swift

@@ -0,0 +1,336 @@
+//
+//  SessionDelegate.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Class which implements the various `URLSessionDelegate` methods to connect various Alamofire features.
+open class SessionDelegate: NSObject {
+    private let fileManager: FileManager
+
+    weak var stateProvider: SessionStateProvider?
+    var eventMonitor: EventMonitor?
+
+    /// Creates an instance from the given `FileManager`.
+    ///
+    /// - Parameter fileManager: `FileManager` to use for underlying file management, such as moving downloaded files.
+    ///                          `.default` by default.
+    public init(fileManager: FileManager = .default) {
+        self.fileManager = fileManager
+    }
+
+    /// Internal method to find and cast requests while maintaining some integrity checking.
+    ///
+    /// - Parameters:
+    ///   - task: The `URLSessionTask` for which to find the associated `Request`.
+    ///   - type: The `Request` subclass type to cast any `Request` associate with `task`.
+    func request<R: Request>(for task: URLSessionTask, as type: R.Type) -> R? {
+        guard let provider = stateProvider else {
+            assertionFailure("StateProvider is nil.")
+            return nil
+        }
+
+        return provider.request(for: task) as? R
+    }
+}
+
+/// Type which provides various `Session` state values.
+protocol SessionStateProvider: AnyObject {
+    var serverTrustManager: ServerTrustManager? { get }
+    var redirectHandler: RedirectHandler? { get }
+    var cachedResponseHandler: CachedResponseHandler? { get }
+
+    func request(for task: URLSessionTask) -> Request?
+    func didGatherMetricsForTask(_ task: URLSessionTask)
+    func didCompleteTask(_ task: URLSessionTask, completion: @escaping () -> Void)
+    func credential(for task: URLSessionTask, in protectionSpace: URLProtectionSpace) -> URLCredential?
+    func cancelRequestsForSessionInvalidation(with error: Error?)
+}
+
+// MARK: URLSessionDelegate
+
+extension SessionDelegate: URLSessionDelegate {
+    open func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {
+        eventMonitor?.urlSession(session, didBecomeInvalidWithError: error)
+
+        stateProvider?.cancelRequestsForSessionInvalidation(with: error)
+    }
+}
+
+// MARK: URLSessionTaskDelegate
+
+extension SessionDelegate: URLSessionTaskDelegate {
+    /// Result of a `URLAuthenticationChallenge` evaluation.
+    typealias ChallengeEvaluation = (disposition: URLSession.AuthChallengeDisposition, credential: URLCredential?, error: AFError?)
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         didReceive challenge: URLAuthenticationChallenge,
+                         completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        eventMonitor?.urlSession(session, task: task, didReceive: challenge)
+
+        let evaluation: ChallengeEvaluation
+        switch challenge.protectionSpace.authenticationMethod {
+        case NSURLAuthenticationMethodHTTPBasic, NSURLAuthenticationMethodHTTPDigest, NSURLAuthenticationMethodNTLM,
+             NSURLAuthenticationMethodNegotiate:
+            evaluation = attemptCredentialAuthentication(for: challenge, belongingTo: task)
+        #if !(os(Linux) || os(Windows))
+        case NSURLAuthenticationMethodServerTrust:
+            evaluation = attemptServerTrustAuthentication(with: challenge)
+        case NSURLAuthenticationMethodClientCertificate:
+            evaluation = attemptCredentialAuthentication(for: challenge, belongingTo: task)
+        #endif
+        default:
+            evaluation = (.performDefaultHandling, nil, nil)
+        }
+
+        if let error = evaluation.error {
+            stateProvider?.request(for: task)?.didFailTask(task, earlyWithError: error)
+        }
+
+        completionHandler(evaluation.disposition, evaluation.credential)
+    }
+
+    #if !(os(Linux) || os(Windows))
+    /// Evaluates the server trust `URLAuthenticationChallenge` received.
+    ///
+    /// - Parameter challenge: The `URLAuthenticationChallenge`.
+    ///
+    /// - Returns:             The `ChallengeEvaluation`.
+    func attemptServerTrustAuthentication(with challenge: URLAuthenticationChallenge) -> ChallengeEvaluation {
+        let host = challenge.protectionSpace.host
+
+        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
+              let trust = challenge.protectionSpace.serverTrust
+        else {
+            return (.performDefaultHandling, nil, nil)
+        }
+
+        do {
+            guard let evaluator = try stateProvider?.serverTrustManager?.serverTrustEvaluator(forHost: host) else {
+                return (.performDefaultHandling, nil, nil)
+            }
+
+            try evaluator.evaluate(trust, forHost: host)
+
+            return (.useCredential, URLCredential(trust: trust), nil)
+        } catch {
+            return (.cancelAuthenticationChallenge, nil, error.asAFError(or: .serverTrustEvaluationFailed(reason: .customEvaluationFailed(error: error))))
+        }
+    }
+    #endif
+
+    /// Evaluates the credential-based authentication `URLAuthenticationChallenge` received for `task`.
+    ///
+    /// - Parameters:
+    ///   - challenge: The `URLAuthenticationChallenge`.
+    ///   - task:      The `URLSessionTask` which received the challenge.
+    ///
+    /// - Returns:     The `ChallengeEvaluation`.
+    func attemptCredentialAuthentication(for challenge: URLAuthenticationChallenge,
+                                         belongingTo task: URLSessionTask) -> ChallengeEvaluation {
+        guard challenge.previousFailureCount == 0 else {
+            return (.rejectProtectionSpace, nil, nil)
+        }
+
+        guard let credential = stateProvider?.credential(for: task, in: challenge.protectionSpace) else {
+            return (.performDefaultHandling, nil, nil)
+        }
+
+        return (.useCredential, credential, nil)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         didSendBodyData bytesSent: Int64,
+                         totalBytesSent: Int64,
+                         totalBytesExpectedToSend: Int64) {
+        eventMonitor?.urlSession(session,
+                                 task: task,
+                                 didSendBodyData: bytesSent,
+                                 totalBytesSent: totalBytesSent,
+                                 totalBytesExpectedToSend: totalBytesExpectedToSend)
+
+        stateProvider?.request(for: task)?.updateUploadProgress(totalBytesSent: totalBytesSent,
+                                                                totalBytesExpectedToSend: totalBytesExpectedToSend)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         needNewBodyStream completionHandler: @escaping (InputStream?) -> Void) {
+        eventMonitor?.urlSession(session, taskNeedsNewBodyStream: task)
+
+        guard let request = request(for: task, as: UploadRequest.self) else {
+            assertionFailure("needNewBodyStream did not find UploadRequest.")
+            completionHandler(nil)
+            return
+        }
+
+        completionHandler(request.inputStream())
+    }
+
+    open func urlSession(_ session: URLSession,
+                         task: URLSessionTask,
+                         willPerformHTTPRedirection response: HTTPURLResponse,
+                         newRequest request: URLRequest,
+                         completionHandler: @escaping (URLRequest?) -> Void) {
+        eventMonitor?.urlSession(session, task: task, willPerformHTTPRedirection: response, newRequest: request)
+
+        if let redirectHandler = stateProvider?.request(for: task)?.redirectHandler ?? stateProvider?.redirectHandler {
+            redirectHandler.task(task, willBeRedirectedTo: request, for: response, completion: completionHandler)
+        } else {
+            completionHandler(request)
+        }
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
+        eventMonitor?.urlSession(session, task: task, didFinishCollecting: metrics)
+
+        stateProvider?.request(for: task)?.didGatherMetrics(metrics)
+
+        stateProvider?.didGatherMetricsForTask(task)
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        eventMonitor?.urlSession(session, task: task, didCompleteWithError: error)
+
+        let request = stateProvider?.request(for: task)
+
+        stateProvider?.didCompleteTask(task) {
+            request?.didCompleteTask(task, with: error.map { $0.asAFError(or: .sessionTaskFailed(error: $0)) })
+        }
+    }
+
+    @available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)
+    open func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask) {
+        eventMonitor?.urlSession(session, taskIsWaitingForConnectivity: task)
+    }
+}
+
+// MARK: URLSessionDataDelegate
+
+extension SessionDelegate: URLSessionDataDelegate {
+    open func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        eventMonitor?.urlSession(session, dataTask: dataTask, didReceive: data)
+
+        if let request = request(for: dataTask, as: DataRequest.self) {
+            request.didReceive(data: data)
+        } else if let request = request(for: dataTask, as: DataStreamRequest.self) {
+            request.didReceive(data: data)
+        } else {
+            assertionFailure("dataTask did not find DataRequest or DataStreamRequest in didReceive")
+            return
+        }
+    }
+
+    open func urlSession(_ session: URLSession,
+                         dataTask: URLSessionDataTask,
+                         willCacheResponse proposedResponse: CachedURLResponse,
+                         completionHandler: @escaping (CachedURLResponse?) -> Void) {
+        eventMonitor?.urlSession(session, dataTask: dataTask, willCacheResponse: proposedResponse)
+
+        if let handler = stateProvider?.request(for: dataTask)?.cachedResponseHandler ?? stateProvider?.cachedResponseHandler {
+            handler.dataTask(dataTask, willCacheResponse: proposedResponse, completion: completionHandler)
+        } else {
+            completionHandler(proposedResponse)
+        }
+    }
+}
+
+// MARK: URLSessionDownloadDelegate
+
+extension SessionDelegate: URLSessionDownloadDelegate {
+    open func urlSession(_ session: URLSession,
+                         downloadTask: URLSessionDownloadTask,
+                         didResumeAtOffset fileOffset: Int64,
+                         expectedTotalBytes: Int64) {
+        eventMonitor?.urlSession(session,
+                                 downloadTask: downloadTask,
+                                 didResumeAtOffset: fileOffset,
+                                 expectedTotalBytes: expectedTotalBytes)
+        guard let downloadRequest = request(for: downloadTask, as: DownloadRequest.self) else {
+            assertionFailure("downloadTask did not find DownloadRequest.")
+            return
+        }
+
+        downloadRequest.updateDownloadProgress(bytesWritten: fileOffset,
+                                               totalBytesExpectedToWrite: expectedTotalBytes)
+    }
+
+    open func urlSession(_ session: URLSession,
+                         downloadTask: URLSessionDownloadTask,
+                         didWriteData bytesWritten: Int64,
+                         totalBytesWritten: Int64,
+                         totalBytesExpectedToWrite: Int64) {
+        eventMonitor?.urlSession(session,
+                                 downloadTask: downloadTask,
+                                 didWriteData: bytesWritten,
+                                 totalBytesWritten: totalBytesWritten,
+                                 totalBytesExpectedToWrite: totalBytesExpectedToWrite)
+        guard let downloadRequest = request(for: downloadTask, as: DownloadRequest.self) else {
+            assertionFailure("downloadTask did not find DownloadRequest.")
+            return
+        }
+
+        downloadRequest.updateDownloadProgress(bytesWritten: bytesWritten,
+                                               totalBytesExpectedToWrite: totalBytesExpectedToWrite)
+    }
+
+    open func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        eventMonitor?.urlSession(session, downloadTask: downloadTask, didFinishDownloadingTo: location)
+
+        guard let request = request(for: downloadTask, as: DownloadRequest.self) else {
+            assertionFailure("downloadTask did not find DownloadRequest.")
+            return
+        }
+
+        let (destination, options): (URL, DownloadRequest.Options)
+        if let response = request.response {
+            (destination, options) = request.destination(location, response)
+        } else {
+            // If there's no response this is likely a local file download, so generate the temporary URL directly.
+            (destination, options) = (DownloadRequest.defaultDestinationURL(location), [])
+        }
+
+        eventMonitor?.request(request, didCreateDestinationURL: destination)
+
+        do {
+            if options.contains(.removePreviousFile), fileManager.fileExists(atPath: destination.path) {
+                try fileManager.removeItem(at: destination)
+            }
+
+            if options.contains(.createIntermediateDirectories) {
+                let directory = destination.deletingLastPathComponent()
+                try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+            }
+
+            try fileManager.moveItem(at: location, to: destination)
+
+            request.didFinishDownloading(using: downloadTask, with: .success(destination))
+        } catch {
+            request.didFinishDownloading(using: downloadTask, with: .failure(.downloadedFileMoveFailed(error: error,
+                                                                                                       source: location,
+                                                                                                       destination: destination)))
+        }
+    }
+}

Pods/Alamofire/Source/StringEncoding+Alamofire.swift

@@ -0,0 +1,55 @@
+//
+//  StringEncoding+Alamofire.swift
+//
+//  Copyright (c) 2020 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension String.Encoding {
+    /// Creates an encoding from the IANA charset name.
+    ///
+    /// - Notes: These mappings match those [provided by CoreFoundation](https://opensource.apple.com/source/CF/CF-476.18/CFStringUtilities.c.auto.html)
+    ///
+    /// - Parameter name: IANA charset name.
+    init?(ianaCharsetName name: String) {
+        switch name.lowercased() {
+        case "utf-8":
+            self = .utf8
+        case "iso-8859-1":
+            self = .isoLatin1
+        case "unicode-1-1", "iso-10646-ucs-2", "utf-16":
+            self = .utf16
+        case "utf-16be":
+            self = .utf16BigEndian
+        case "utf-16le":
+            self = .utf16LittleEndian
+        case "utf-32":
+            self = .utf32
+        case "utf-32be":
+            self = .utf32BigEndian
+        case "utf-32le":
+            self = .utf32LittleEndian
+        default:
+            return nil
+        }
+    }
+}

Pods/Alamofire/Source/URLConvertible+URLRequestConvertible.swift

@@ -0,0 +1,105 @@
+//
+//  URLConvertible+URLRequestConvertible.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// Types adopting the `URLConvertible` protocol can be used to construct `URL`s, which can then be used to construct
+/// `URLRequests`.
+public protocol URLConvertible {
+    /// Returns a `URL` from the conforming instance or throws.
+    ///
+    /// - Returns: The `URL` created from the instance.
+    /// - Throws:  Any error thrown while creating the `URL`.
+    func asURL() throws -> URL
+}
+
+extension String: URLConvertible {
+    /// Returns a `URL` if `self` can be used to initialize a `URL` instance, otherwise throws.
+    ///
+    /// - Returns: The `URL` initialized with `self`.
+    /// - Throws:  An `AFError.invalidURL` instance.
+    public func asURL() throws -> URL {
+        guard let url = URL(string: self) else { throw AFError.invalidURL(url: self) }
+
+        return url
+    }
+}
+
+extension URL: URLConvertible {
+    /// Returns `self`.
+    public func asURL() throws -> URL { self }
+}
+
+extension URLComponents: URLConvertible {
+    /// Returns a `URL` if the `self`'s `url` is not nil, otherwise throws.
+    ///
+    /// - Returns: The `URL` from the `url` property.
+    /// - Throws:  An `AFError.invalidURL` instance.
+    public func asURL() throws -> URL {
+        guard let url = url else { throw AFError.invalidURL(url: self) }
+
+        return url
+    }
+}
+
+// MARK: -
+
+/// Types adopting the `URLRequestConvertible` protocol can be used to safely construct `URLRequest`s.
+public protocol URLRequestConvertible {
+    /// Returns a `URLRequest` or throws if an `Error` was encountered.
+    ///
+    /// - Returns: A `URLRequest`.
+    /// - Throws:  Any error thrown while constructing the `URLRequest`.
+    func asURLRequest() throws -> URLRequest
+}
+
+extension URLRequestConvertible {
+    /// The `URLRequest` returned by discarding any `Error` encountered.
+    public var urlRequest: URLRequest? { try? asURLRequest() }
+}
+
+extension URLRequest: URLRequestConvertible {
+    /// Returns `self`.
+    public func asURLRequest() throws -> URLRequest { self }
+}
+
+// MARK: -
+
+extension URLRequest {
+    /// Creates an instance with the specified `url`, `method`, and `headers`.
+    ///
+    /// - Parameters:
+    ///   - url:     The `URLConvertible` value.
+    ///   - method:  The `HTTPMethod`.
+    ///   - headers: The `HTTPHeaders`, `nil` by default.
+    /// - Throws:    Any error thrown while converting the `URLConvertible` to a `URL`.
+    public init(url: URLConvertible, method: HTTPMethod, headers: HTTPHeaders? = nil) throws {
+        let url = try url.asURL()
+
+        self.init(url: url)
+
+        httpMethod = method.rawValue
+        allHTTPHeaderFields = headers?.dictionary
+    }
+}

Pods/Alamofire/Source/URLEncodedFormEncoder.swift

@@ -0,0 +1,976 @@
+//
+//  URLEncodedFormEncoder.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+/// An object that encodes instances into URL-encoded query strings.
+///
+/// There is no published specification for how to encode collection types. By default, the convention of appending
+/// `[]` to the key for array values (`foo[]=1&foo[]=2`), and appending the key surrounded by square brackets for
+/// nested dictionary values (`foo[bar]=baz`) is used. Optionally, `ArrayEncoding` can be used to omit the
+/// square brackets appended to array keys.
+///
+/// `BoolEncoding` can be used to configure how `Bool` values are encoded. The default behavior is to encode
+/// `true` as 1 and `false` as 0.
+///
+/// `DateEncoding` can be used to configure how `Date` values are encoded. By default, the `.deferredToDate`
+/// strategy is used, which formats dates from their structure.
+///
+/// `SpaceEncoding` can be used to configure how spaces are encoded. Modern encodings use percent replacement (`%20`),
+/// while older encodings may expect spaces to be replaced with `+`.
+///
+/// This type is largely based on Vapor's [`url-encoded-form`](https://github.com/vapor/url-encoded-form) project.
+public final class URLEncodedFormEncoder {
+    /// Encoding to use for `Array` values.
+    public enum ArrayEncoding {
+        /// An empty set of square brackets ("[]") are appended to the key for every value. This is the default encoding.
+        case brackets
+        /// No brackets are appended to the key and the key is encoded as is.
+        case noBrackets
+
+        /// Encodes the key according to the encoding.
+        ///
+        /// - Parameter key: The `key` to encode.
+        /// - Returns:       The encoded key.
+        func encode(_ key: String) -> String {
+            switch self {
+            case .brackets: return "\(key)[]"
+            case .noBrackets: return key
+            }
+        }
+    }
+
+    /// Encoding to use for `Bool` values.
+    public enum BoolEncoding {
+        /// Encodes `true` as `1`, `false` as `0`.
+        case numeric
+        /// Encodes `true` as "true", `false` as "false". This is the default encoding.
+        case literal
+
+        /// Encodes the given `Bool` as a `String`.
+        ///
+        /// - Parameter value: The `Bool` to encode.
+        ///
+        /// - Returns:         The encoded `String`.
+        func encode(_ value: Bool) -> String {
+            switch self {
+            case .numeric: return value ? "1" : "0"
+            case .literal: return value ? "true" : "false"
+            }
+        }
+    }
+
+    /// Encoding to use for `Data` values.
+    public enum DataEncoding {
+        /// Defers encoding to the `Data` type.
+        case deferredToData
+        /// Encodes `Data` as a Base64-encoded string. This is the default encoding.
+        case base64
+        /// Encode the `Data` as a custom value encoded by the given closure.
+        case custom((Data) throws -> String)
+
+        /// Encodes `Data` according to the encoding.
+        ///
+        /// - Parameter data: The `Data` to encode.
+        ///
+        /// - Returns:        The encoded `String`, or `nil` if the `Data` should be encoded according to its
+        ///                   `Encodable` implementation.
+        func encode(_ data: Data) throws -> String? {
+            switch self {
+            case .deferredToData: return nil
+            case .base64: return data.base64EncodedString()
+            case let .custom(encoding): return try encoding(data)
+            }
+        }
+    }
+
+    /// Encoding to use for `Date` values.
+    public enum DateEncoding {
+        /// ISO8601 and RFC3339 formatter.
+        private static let iso8601Formatter: ISO8601DateFormatter = {
+            let formatter = ISO8601DateFormatter()
+            formatter.formatOptions = .withInternetDateTime
+            return formatter
+        }()
+
+        /// Defers encoding to the `Date` type. This is the default encoding.
+        case deferredToDate
+        /// Encodes `Date`s as seconds since midnight UTC on January 1, 1970.
+        case secondsSince1970
+        /// Encodes `Date`s as milliseconds since midnight UTC on January 1, 1970.
+        case millisecondsSince1970
+        /// Encodes `Date`s according to the ISO8601 and RFC3339 standards.
+        case iso8601
+        /// Encodes `Date`s using the given `DateFormatter`.
+        case formatted(DateFormatter)
+        /// Encodes `Date`s using the given closure.
+        case custom((Date) throws -> String)
+
+        /// Encodes the date according to the encoding.
+        ///
+        /// - Parameter date: The `Date` to encode.
+        ///
+        /// - Returns:        The encoded `String`, or `nil` if the `Date` should be encoded according to its
+        ///                   `Encodable` implementation.
+        func encode(_ date: Date) throws -> String? {
+            switch self {
+            case .deferredToDate:
+                return nil
+            case .secondsSince1970:
+                return String(date.timeIntervalSince1970)
+            case .millisecondsSince1970:
+                return String(date.timeIntervalSince1970 * 1000.0)
+            case .iso8601:
+                return DateEncoding.iso8601Formatter.string(from: date)
+            case let .formatted(formatter):
+                return formatter.string(from: date)
+            case let .custom(closure):
+                return try closure(date)
+            }
+        }
+    }
+
+    /// Encoding to use for keys.
+    ///
+    /// This type is derived from [`JSONEncoder`'s `KeyEncodingStrategy`](https://github.com/apple/swift/blob/6aa313b8dd5f05135f7f878eccc1db6f9fbe34ff/stdlib/public/Darwin/Foundation/JSONEncoder.swift#L128)
+    /// and [`XMLEncoder`s `KeyEncodingStrategy`](https://github.com/MaxDesiatov/XMLCoder/blob/master/Sources/XMLCoder/Encoder/XMLEncoder.swift#L102).
+    public enum KeyEncoding {
+        /// Use the keys specified by each type. This is the default encoding.
+        case useDefaultKeys
+        /// Convert from "camelCaseKeys" to "snake_case_keys" before writing a key.
+        ///
+        /// Capital characters are determined by testing membership in
+        /// `CharacterSet.uppercaseLetters` and `CharacterSet.lowercaseLetters`
+        /// (Unicode General Categories Lu and Lt).
+        /// The conversion to lower case uses `Locale.system`, also known as
+        /// the ICU "root" locale. This means the result is consistent
+        /// regardless of the current user's locale and language preferences.
+        ///
+        /// Converting from camel case to snake case:
+        /// 1. Splits words at the boundary of lower-case to upper-case
+        /// 2. Inserts `_` between words
+        /// 3. Lowercases the entire string
+        /// 4. Preserves starting and ending `_`.
+        ///
+        /// For example, `oneTwoThree` becomes `one_two_three`. `_oneTwoThree_` becomes `_one_two_three_`.
+        ///
+        /// - Note: Using a key encoding strategy has a nominal performance cost, as each string key has to be converted.
+        case convertToSnakeCase
+        /// Same as convertToSnakeCase, but using `-` instead of `_`.
+        /// For example `oneTwoThree` becomes `one-two-three`.
+        case convertToKebabCase
+        /// Capitalize the first letter only.
+        /// For example `oneTwoThree` becomes  `OneTwoThree`.
+        case capitalized
+        /// Uppercase all letters.
+        /// For example `oneTwoThree` becomes  `ONETWOTHREE`.
+        case uppercased
+        /// Lowercase all letters.
+        /// For example `oneTwoThree` becomes  `onetwothree`.
+        case lowercased
+        /// A custom encoding using the provided closure.
+        case custom((String) -> String)
+
+        func encode(_ key: String) -> String {
+            switch self {
+            case .useDefaultKeys: return key
+            case .convertToSnakeCase: return convertToSnakeCase(key)
+            case .convertToKebabCase: return convertToKebabCase(key)
+            case .capitalized: return String(key.prefix(1).uppercased() + key.dropFirst())
+            case .uppercased: return key.uppercased()
+            case .lowercased: return key.lowercased()
+            case let .custom(encoding): return encoding(key)
+            }
+        }
+
+        private func convertToSnakeCase(_ key: String) -> String {
+            convert(key, usingSeparator: "_")
+        }
+
+        private func convertToKebabCase(_ key: String) -> String {
+            convert(key, usingSeparator: "-")
+        }
+
+        private func convert(_ key: String, usingSeparator separator: String) -> String {
+            guard !key.isEmpty else { return key }
+
+            var words: [Range<String.Index>] = []
+            // The general idea of this algorithm is to split words on
+            // transition from lower to upper case, then on transition of >1
+            // upper case characters to lowercase
+            //
+            // myProperty -> my_property
+            // myURLProperty -> my_url_property
+            //
+            // It is assumed, per Swift naming conventions, that the first character of the key is lowercase.
+            var wordStart = key.startIndex
+            var searchRange = key.index(after: wordStart)..<key.endIndex
+
+            // Find next uppercase character
+            while let upperCaseRange = key.rangeOfCharacter(from: CharacterSet.uppercaseLetters, options: [], range: searchRange) {
+                let untilUpperCase = wordStart..<upperCaseRange.lowerBound
+                words.append(untilUpperCase)
+
+                // Find next lowercase character
+                searchRange = upperCaseRange.lowerBound..<searchRange.upperBound
+                guard let lowerCaseRange = key.rangeOfCharacter(from: CharacterSet.lowercaseLetters, options: [], range: searchRange) else {
+                    // There are no more lower case letters. Just end here.
+                    wordStart = searchRange.lowerBound
+                    break
+                }
+
+                // Is the next lowercase letter more than 1 after the uppercase?
+                // If so, we encountered a group of uppercase letters that we
+                // should treat as its own word
+                let nextCharacterAfterCapital = key.index(after: upperCaseRange.lowerBound)
+                if lowerCaseRange.lowerBound == nextCharacterAfterCapital {
+                    // The next character after capital is a lower case character and therefore not a word boundary.
+                    // Continue searching for the next upper case for the boundary.
+                    wordStart = upperCaseRange.lowerBound
+                } else {
+                    // There was a range of >1 capital letters. Turn those into a word, stopping at the capital before the lower case character.
+                    let beforeLowerIndex = key.index(before: lowerCaseRange.lowerBound)
+                    words.append(upperCaseRange.lowerBound..<beforeLowerIndex)
+
+                    // Next word starts at the capital before the lowercase we just found
+                    wordStart = beforeLowerIndex
+                }
+                searchRange = lowerCaseRange.upperBound..<searchRange.upperBound
+            }
+            words.append(wordStart..<searchRange.upperBound)
+            let result = words.map { range in
+                key[range].lowercased()
+            }.joined(separator: separator)
+
+            return result
+        }
+    }
+
+    /// Encoding to use for spaces.
+    public enum SpaceEncoding {
+        /// Encodes spaces according to normal percent escaping rules (%20).
+        case percentEscaped
+        /// Encodes spaces as `+`,
+        case plusReplaced
+
+        /// Encodes the string according to the encoding.
+        ///
+        /// - Parameter string: The `String` to encode.
+        ///
+        /// - Returns:          The encoded `String`.
+        func encode(_ string: String) -> String {
+            switch self {
+            case .percentEscaped: return string.replacingOccurrences(of: " ", with: "%20")
+            case .plusReplaced: return string.replacingOccurrences(of: " ", with: "+")
+            }
+        }
+    }
+
+    /// `URLEncodedFormEncoder` error.
+    public enum Error: Swift.Error {
+        /// An invalid root object was created by the encoder. Only keyed values are valid.
+        case invalidRootObject(String)
+
+        var localizedDescription: String {
+            switch self {
+            case let .invalidRootObject(object):
+                return "URLEncodedFormEncoder requires keyed root object. Received \(object) instead."
+            }
+        }
+    }
+
+    /// Whether or not to sort the encoded key value pairs.
+    ///
+    /// - Note: This setting ensures a consistent ordering for all encodings of the same parameters. When set to `false`,
+    ///         encoded `Dictionary` values may have a different encoded order each time they're encoded due to
+    ///       ` Dictionary`'s random storage order, but `Encodable` types will maintain their encoded order.
+    public let alphabetizeKeyValuePairs: Bool
+    /// The `ArrayEncoding` to use.
+    public let arrayEncoding: ArrayEncoding
+    /// The `BoolEncoding` to use.
+    public let boolEncoding: BoolEncoding
+    /// THe `DataEncoding` to use.
+    public let dataEncoding: DataEncoding
+    /// The `DateEncoding` to use.
+    public let dateEncoding: DateEncoding
+    /// The `KeyEncoding` to use.
+    public let keyEncoding: KeyEncoding
+    /// The `SpaceEncoding` to use.
+    public let spaceEncoding: SpaceEncoding
+    /// The `CharacterSet` of allowed (non-escaped) characters.
+    public var allowedCharacters: CharacterSet
+
+    /// Creates an instance from the supplied parameters.
+    ///
+    /// - Parameters:
+    ///   - alphabetizeKeyValuePairs: Whether or not to sort the encoded key value pairs. `true` by default.
+    ///   - arrayEncoding:            The `ArrayEncoding` to use. `.brackets` by default.
+    ///   - boolEncoding:             The `BoolEncoding` to use. `.numeric` by default.
+    ///   - dataEncoding:             The `DataEncoding` to use. `.base64` by default.
+    ///   - dateEncoding:             The `DateEncoding` to use. `.deferredToDate` by default.
+    ///   - keyEncoding:              The `KeyEncoding` to use. `.useDefaultKeys` by default.
+    ///   - spaceEncoding:            The `SpaceEncoding` to use. `.percentEscaped` by default.
+    ///   - allowedCharacters:        The `CharacterSet` of allowed (non-escaped) characters. `.afURLQueryAllowed` by
+    ///                               default.
+    public init(alphabetizeKeyValuePairs: Bool = true,
+                arrayEncoding: ArrayEncoding = .brackets,
+                boolEncoding: BoolEncoding = .numeric,
+                dataEncoding: DataEncoding = .base64,
+                dateEncoding: DateEncoding = .deferredToDate,
+                keyEncoding: KeyEncoding = .useDefaultKeys,
+                spaceEncoding: SpaceEncoding = .percentEscaped,
+                allowedCharacters: CharacterSet = .afURLQueryAllowed) {
+        self.alphabetizeKeyValuePairs = alphabetizeKeyValuePairs
+        self.arrayEncoding = arrayEncoding
+        self.boolEncoding = boolEncoding
+        self.dataEncoding = dataEncoding
+        self.dateEncoding = dateEncoding
+        self.keyEncoding = keyEncoding
+        self.spaceEncoding = spaceEncoding
+        self.allowedCharacters = allowedCharacters
+    }
+
+    func encode(_ value: Encodable) throws -> URLEncodedFormComponent {
+        let context = URLEncodedFormContext(.object([]))
+        let encoder = _URLEncodedFormEncoder(context: context,
+                                             boolEncoding: boolEncoding,
+                                             dataEncoding: dataEncoding,
+                                             dateEncoding: dateEncoding)
+        try value.encode(to: encoder)
+
+        return context.component
+    }
+
+    /// Encodes the `value` as a URL form encoded `String`.
+    ///
+    /// - Parameter value: The `Encodable` value.`
+    ///
+    /// - Returns:         The encoded `String`.
+    /// - Throws:          An `Error` or `EncodingError` instance if encoding fails.
+    public func encode(_ value: Encodable) throws -> String {
+        let component: URLEncodedFormComponent = try encode(value)
+
+        guard case let .object(object) = component else {
+            throw Error.invalidRootObject("\(component)")
+        }
+
+        let serializer = URLEncodedFormSerializer(alphabetizeKeyValuePairs: alphabetizeKeyValuePairs,
+                                                  arrayEncoding: arrayEncoding,
+                                                  keyEncoding: keyEncoding,
+                                                  spaceEncoding: spaceEncoding,
+                                                  allowedCharacters: allowedCharacters)
+        let query = serializer.serialize(object)
+
+        return query
+    }
+
+    /// Encodes the value as `Data`. This is performed by first creating an encoded `String` and then returning the
+    /// `.utf8` data.
+    ///
+    /// - Parameter value: The `Encodable` value.
+    ///
+    /// - Returns:         The encoded `Data`.
+    ///
+    /// - Throws:          An `Error` or `EncodingError` instance if encoding fails.
+    public func encode(_ value: Encodable) throws -> Data {
+        let string: String = try encode(value)
+
+        return Data(string.utf8)
+    }
+}
+
+final class _URLEncodedFormEncoder {
+    var codingPath: [CodingKey]
+    // Returns an empty dictionary, as this encoder doesn't support userInfo.
+    var userInfo: [CodingUserInfoKey: Any] { [:] }
+
+    let context: URLEncodedFormContext
+
+    private let boolEncoding: URLEncodedFormEncoder.BoolEncoding
+    private let dataEncoding: URLEncodedFormEncoder.DataEncoding
+    private let dateEncoding: URLEncodedFormEncoder.DateEncoding
+
+    init(context: URLEncodedFormContext,
+         codingPath: [CodingKey] = [],
+         boolEncoding: URLEncodedFormEncoder.BoolEncoding,
+         dataEncoding: URLEncodedFormEncoder.DataEncoding,
+         dateEncoding: URLEncodedFormEncoder.DateEncoding) {
+        self.context = context
+        self.codingPath = codingPath
+        self.boolEncoding = boolEncoding
+        self.dataEncoding = dataEncoding
+        self.dateEncoding = dateEncoding
+    }
+}
+
+extension _URLEncodedFormEncoder: Encoder {
+    func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
+        let container = _URLEncodedFormEncoder.KeyedContainer<Key>(context: context,
+                                                                   codingPath: codingPath,
+                                                                   boolEncoding: boolEncoding,
+                                                                   dataEncoding: dataEncoding,
+                                                                   dateEncoding: dateEncoding)
+        return KeyedEncodingContainer(container)
+    }
+
+    func unkeyedContainer() -> UnkeyedEncodingContainer {
+        _URLEncodedFormEncoder.UnkeyedContainer(context: context,
+                                                codingPath: codingPath,
+                                                boolEncoding: boolEncoding,
+                                                dataEncoding: dataEncoding,
+                                                dateEncoding: dateEncoding)
+    }
+
+    func singleValueContainer() -> SingleValueEncodingContainer {
+        _URLEncodedFormEncoder.SingleValueContainer(context: context,
+                                                    codingPath: codingPath,
+                                                    boolEncoding: boolEncoding,
+                                                    dataEncoding: dataEncoding,
+                                                    dateEncoding: dateEncoding)
+    }
+}
+
+final class URLEncodedFormContext {
+    var component: URLEncodedFormComponent
+
+    init(_ component: URLEncodedFormComponent) {
+        self.component = component
+    }
+}
+
+enum URLEncodedFormComponent {
+    typealias Object = [(key: String, value: URLEncodedFormComponent)]
+
+    case string(String)
+    case array([URLEncodedFormComponent])
+    case object(Object)
+
+    /// Converts self to an `[URLEncodedFormData]` or returns `nil` if not convertible.
+    var array: [URLEncodedFormComponent]? {
+        switch self {
+        case let .array(array): return array
+        default: return nil
+        }
+    }
+
+    /// Converts self to an `Object` or returns `nil` if not convertible.
+    var object: Object? {
+        switch self {
+        case let .object(object): return object
+        default: return nil
+        }
+    }
+
+    /// Sets self to the supplied value at a given path.
+    ///
+    ///     data.set(to: "hello", at: ["path", "to", "value"])
+    ///
+    /// - parameters:
+    ///     - value: Value of `Self` to set at the supplied path.
+    ///     - path: `CodingKey` path to update with the supplied value.
+    public mutating func set(to value: URLEncodedFormComponent, at path: [CodingKey]) {
+        set(&self, to: value, at: path)
+    }
+
+    /// Recursive backing method to `set(to:at:)`.
+    private func set(_ context: inout URLEncodedFormComponent, to value: URLEncodedFormComponent, at path: [CodingKey]) {
+        guard !path.isEmpty else {
+            context = value
+            return
+        }
+
+        let end = path[0]
+        var child: URLEncodedFormComponent
+        switch path.count {
+        case 1:
+            child = value
+        case 2...:
+            if let index = end.intValue {
+                let array = context.array ?? []
+                if array.count > index {
+                    child = array[index]
+                } else {
+                    child = .array([])
+                }
+                set(&child, to: value, at: Array(path[1...]))
+            } else {
+                child = context.object?.first { $0.key == end.stringValue }?.value ?? .object(.init())
+                set(&child, to: value, at: Array(path[1...]))
+            }
+        default: fatalError("Unreachable")
+        }
+
+        if let index = end.intValue {
+            if var array = context.array {
+                if array.count > index {
+                    array[index] = child
+                } else {
+                    array.append(child)
+                }
+                context = .array(array)
+            } else {
+                context = .array([child])
+            }
+        } else {
+            if var object = context.object {
+                if let index = object.firstIndex(where: { $0.key == end.stringValue }) {
+                    object[index] = (key: end.stringValue, value: child)
+                } else {
+                    object.append((key: end.stringValue, value: child))
+                }
+                context = .object(object)
+            } else {
+                context = .object([(key: end.stringValue, value: child)])
+            }
+        }
+    }
+}
+
+struct AnyCodingKey: CodingKey, Hashable {
+    let stringValue: String
+    let intValue: Int?
+
+    init?(stringValue: String) {
+        self.stringValue = stringValue
+        intValue = nil
+    }
+
+    init?(intValue: Int) {
+        stringValue = "\(intValue)"
+        self.intValue = intValue
+    }
+
+    init<Key>(_ base: Key) where Key: CodingKey {
+        if let intValue = base.intValue {
+            self.init(intValue: intValue)!
+        } else {
+            self.init(stringValue: base.stringValue)!
+        }
+    }
+}
+
+extension _URLEncodedFormEncoder {
+    final class KeyedContainer<Key> where Key: CodingKey {
+        var codingPath: [CodingKey]
+
+        private let context: URLEncodedFormContext
+        private let boolEncoding: URLEncodedFormEncoder.BoolEncoding
+        private let dataEncoding: URLEncodedFormEncoder.DataEncoding
+        private let dateEncoding: URLEncodedFormEncoder.DateEncoding
+
+        init(context: URLEncodedFormContext,
+             codingPath: [CodingKey],
+             boolEncoding: URLEncodedFormEncoder.BoolEncoding,
+             dataEncoding: URLEncodedFormEncoder.DataEncoding,
+             dateEncoding: URLEncodedFormEncoder.DateEncoding) {
+            self.context = context
+            self.codingPath = codingPath
+            self.boolEncoding = boolEncoding
+            self.dataEncoding = dataEncoding
+            self.dateEncoding = dateEncoding
+        }
+
+        private func nestedCodingPath(for key: CodingKey) -> [CodingKey] {
+            codingPath + [key]
+        }
+    }
+}
+
+extension _URLEncodedFormEncoder.KeyedContainer: KeyedEncodingContainerProtocol {
+    func encodeNil(forKey key: Key) throws {
+        let context = EncodingError.Context(codingPath: codingPath,
+                                            debugDescription: "URLEncodedFormEncoder cannot encode nil values.")
+        throw EncodingError.invalidValue("\(key): nil", context)
+    }
+
+    func encode<T>(_ value: T, forKey key: Key) throws where T: Encodable {
+        var container = nestedSingleValueEncoder(for: key)
+        try container.encode(value)
+    }
+
+    func nestedSingleValueEncoder(for key: Key) -> SingleValueEncodingContainer {
+        let container = _URLEncodedFormEncoder.SingleValueContainer(context: context,
+                                                                    codingPath: nestedCodingPath(for: key),
+                                                                    boolEncoding: boolEncoding,
+                                                                    dataEncoding: dataEncoding,
+                                                                    dateEncoding: dateEncoding)
+
+        return container
+    }
+
+    func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {
+        let container = _URLEncodedFormEncoder.UnkeyedContainer(context: context,
+                                                                codingPath: nestedCodingPath(for: key),
+                                                                boolEncoding: boolEncoding,
+                                                                dataEncoding: dataEncoding,
+                                                                dateEncoding: dateEncoding)
+
+        return container
+    }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
+        let container = _URLEncodedFormEncoder.KeyedContainer<NestedKey>(context: context,
+                                                                         codingPath: nestedCodingPath(for: key),
+                                                                         boolEncoding: boolEncoding,
+                                                                         dataEncoding: dataEncoding,
+                                                                         dateEncoding: dateEncoding)
+
+        return KeyedEncodingContainer(container)
+    }
+
+    func superEncoder() -> Encoder {
+        _URLEncodedFormEncoder(context: context,
+                               codingPath: codingPath,
+                               boolEncoding: boolEncoding,
+                               dataEncoding: dataEncoding,
+                               dateEncoding: dateEncoding)
+    }
+
+    func superEncoder(forKey key: Key) -> Encoder {
+        _URLEncodedFormEncoder(context: context,
+                               codingPath: nestedCodingPath(for: key),
+                               boolEncoding: boolEncoding,
+                               dataEncoding: dataEncoding,
+                               dateEncoding: dateEncoding)
+    }
+}
+
+extension _URLEncodedFormEncoder {
+    final class SingleValueContainer {
+        var codingPath: [CodingKey]
+
+        private var canEncodeNewValue = true
+
+        private let context: URLEncodedFormContext
+        private let boolEncoding: URLEncodedFormEncoder.BoolEncoding
+        private let dataEncoding: URLEncodedFormEncoder.DataEncoding
+        private let dateEncoding: URLEncodedFormEncoder.DateEncoding
+
+        init(context: URLEncodedFormContext,
+             codingPath: [CodingKey],
+             boolEncoding: URLEncodedFormEncoder.BoolEncoding,
+             dataEncoding: URLEncodedFormEncoder.DataEncoding,
+             dateEncoding: URLEncodedFormEncoder.DateEncoding) {
+            self.context = context
+            self.codingPath = codingPath
+            self.boolEncoding = boolEncoding
+            self.dataEncoding = dataEncoding
+            self.dateEncoding = dateEncoding
+        }
+
+        private func checkCanEncode(value: Any?) throws {
+            guard canEncodeNewValue else {
+                let context = EncodingError.Context(codingPath: codingPath,
+                                                    debugDescription: "Attempt to encode value through single value container when previously value already encoded.")
+                throw EncodingError.invalidValue(value as Any, context)
+            }
+        }
+    }
+}
+
+extension _URLEncodedFormEncoder.SingleValueContainer: SingleValueEncodingContainer {
+    func encodeNil() throws {
+        try checkCanEncode(value: nil)
+        defer { canEncodeNewValue = false }
+
+        let context = EncodingError.Context(codingPath: codingPath,
+                                            debugDescription: "URLEncodedFormEncoder cannot encode nil values.")
+        throw EncodingError.invalidValue("nil", context)
+    }
+
+    func encode(_ value: Bool) throws {
+        try encode(value, as: String(boolEncoding.encode(value)))
+    }
+
+    func encode(_ value: String) throws {
+        try encode(value, as: value)
+    }
+
+    func encode(_ value: Double) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Float) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Int) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Int8) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Int16) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Int32) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: Int64) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: UInt) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: UInt8) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: UInt16) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: UInt32) throws {
+        try encode(value, as: String(value))
+    }
+
+    func encode(_ value: UInt64) throws {
+        try encode(value, as: String(value))
+    }
+
+    private func encode<T>(_ value: T, as string: String) throws where T: Encodable {
+        try checkCanEncode(value: value)
+        defer { canEncodeNewValue = false }
+
+        context.component.set(to: .string(string), at: codingPath)
+    }
+
+    func encode<T>(_ value: T) throws where T: Encodable {
+        switch value {
+        case let date as Date:
+            guard let string = try dateEncoding.encode(date) else {
+                try attemptToEncode(value)
+                return
+            }
+
+            try encode(value, as: string)
+        case let data as Data:
+            guard let string = try dataEncoding.encode(data) else {
+                try attemptToEncode(value)
+                return
+            }
+
+            try encode(value, as: string)
+        case let decimal as Decimal:
+            // Decimal's `Encodable` implementation returns an object, not a single value, so override it.
+            try encode(value, as: String(describing: decimal))
+        default:
+            try attemptToEncode(value)
+        }
+    }
+
+    private func attemptToEncode<T>(_ value: T) throws where T: Encodable {
+        try checkCanEncode(value: value)
+        defer { canEncodeNewValue = false }
+
+        let encoder = _URLEncodedFormEncoder(context: context,
+                                             codingPath: codingPath,
+                                             boolEncoding: boolEncoding,
+                                             dataEncoding: dataEncoding,
+                                             dateEncoding: dateEncoding)
+        try value.encode(to: encoder)
+    }
+}
+
+extension _URLEncodedFormEncoder {
+    final class UnkeyedContainer {
+        var codingPath: [CodingKey]
+
+        var count = 0
+        var nestedCodingPath: [CodingKey] {
+            codingPath + [AnyCodingKey(intValue: count)!]
+        }
+
+        private let context: URLEncodedFormContext
+        private let boolEncoding: URLEncodedFormEncoder.BoolEncoding
+        private let dataEncoding: URLEncodedFormEncoder.DataEncoding
+        private let dateEncoding: URLEncodedFormEncoder.DateEncoding
+
+        init(context: URLEncodedFormContext,
+             codingPath: [CodingKey],
+             boolEncoding: URLEncodedFormEncoder.BoolEncoding,
+             dataEncoding: URLEncodedFormEncoder.DataEncoding,
+             dateEncoding: URLEncodedFormEncoder.DateEncoding) {
+            self.context = context
+            self.codingPath = codingPath
+            self.boolEncoding = boolEncoding
+            self.dataEncoding = dataEncoding
+            self.dateEncoding = dateEncoding
+        }
+    }
+}
+
+extension _URLEncodedFormEncoder.UnkeyedContainer: UnkeyedEncodingContainer {
+    func encodeNil() throws {
+        let context = EncodingError.Context(codingPath: codingPath,
+                                            debugDescription: "URLEncodedFormEncoder cannot encode nil values.")
+        throw EncodingError.invalidValue("nil", context)
+    }
+
+    func encode<T>(_ value: T) throws where T: Encodable {
+        var container = nestedSingleValueContainer()
+        try container.encode(value)
+    }
+
+    func nestedSingleValueContainer() -> SingleValueEncodingContainer {
+        defer { count += 1 }
+
+        return _URLEncodedFormEncoder.SingleValueContainer(context: context,
+                                                           codingPath: nestedCodingPath,
+                                                           boolEncoding: boolEncoding,
+                                                           dataEncoding: dataEncoding,
+                                                           dateEncoding: dateEncoding)
+    }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
+        defer { count += 1 }
+        let container = _URLEncodedFormEncoder.KeyedContainer<NestedKey>(context: context,
+                                                                         codingPath: nestedCodingPath,
+                                                                         boolEncoding: boolEncoding,
+                                                                         dataEncoding: dataEncoding,
+                                                                         dateEncoding: dateEncoding)
+
+        return KeyedEncodingContainer(container)
+    }
+
+    func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {
+        defer { count += 1 }
+
+        return _URLEncodedFormEncoder.UnkeyedContainer(context: context,
+                                                       codingPath: nestedCodingPath,
+                                                       boolEncoding: boolEncoding,
+                                                       dataEncoding: dataEncoding,
+                                                       dateEncoding: dateEncoding)
+    }
+
+    func superEncoder() -> Encoder {
+        defer { count += 1 }
+
+        return _URLEncodedFormEncoder(context: context,
+                                      codingPath: codingPath,
+                                      boolEncoding: boolEncoding,
+                                      dataEncoding: dataEncoding,
+                                      dateEncoding: dateEncoding)
+    }
+}
+
+final class URLEncodedFormSerializer {
+    private let alphabetizeKeyValuePairs: Bool
+    private let arrayEncoding: URLEncodedFormEncoder.ArrayEncoding
+    private let keyEncoding: URLEncodedFormEncoder.KeyEncoding
+    private let spaceEncoding: URLEncodedFormEncoder.SpaceEncoding
+    private let allowedCharacters: CharacterSet
+
+    init(alphabetizeKeyValuePairs: Bool,
+         arrayEncoding: URLEncodedFormEncoder.ArrayEncoding,
+         keyEncoding: URLEncodedFormEncoder.KeyEncoding,
+         spaceEncoding: URLEncodedFormEncoder.SpaceEncoding,
+         allowedCharacters: CharacterSet) {
+        self.alphabetizeKeyValuePairs = alphabetizeKeyValuePairs
+        self.arrayEncoding = arrayEncoding
+        self.keyEncoding = keyEncoding
+        self.spaceEncoding = spaceEncoding
+        self.allowedCharacters = allowedCharacters
+    }
+
+    func serialize(_ object: URLEncodedFormComponent.Object) -> String {
+        var output: [String] = []
+        for (key, component) in object {
+            let value = serialize(component, forKey: key)
+            output.append(value)
+        }
+        output = alphabetizeKeyValuePairs ? output.sorted() : output
+
+        return output.joinedWithAmpersands()
+    }
+
+    func serialize(_ component: URLEncodedFormComponent, forKey key: String) -> String {
+        switch component {
+        case let .string(string): return "\(escape(keyEncoding.encode(key)))=\(escape(string))"
+        case let .array(array): return serialize(array, forKey: key)
+        case let .object(object): return serialize(object, forKey: key)
+        }
+    }
+
+    func serialize(_ object: URLEncodedFormComponent.Object, forKey key: String) -> String {
+        var segments: [String] = object.map { subKey, value in
+            let keyPath = "[\(subKey)]"
+            return serialize(value, forKey: key + keyPath)
+        }
+        segments = alphabetizeKeyValuePairs ? segments.sorted() : segments
+
+        return segments.joinedWithAmpersands()
+    }
+
+    func serialize(_ array: [URLEncodedFormComponent], forKey key: String) -> String {
+        var segments: [String] = array.map { component in
+            let keyPath = arrayEncoding.encode(key)
+            return serialize(component, forKey: keyPath)
+        }
+        segments = alphabetizeKeyValuePairs ? segments.sorted() : segments
+
+        return segments.joinedWithAmpersands()
+    }
+
+    func escape(_ query: String) -> String {
+        var allowedCharactersWithSpace = allowedCharacters
+        allowedCharactersWithSpace.insert(charactersIn: " ")
+        let escapedQuery = query.addingPercentEncoding(withAllowedCharacters: allowedCharactersWithSpace) ?? query
+        let spaceEncodedQuery = spaceEncoding.encode(escapedQuery)
+
+        return spaceEncodedQuery
+    }
+}
+
+extension Array where Element == String {
+    func joinedWithAmpersands() -> String {
+        joined(separator: "&")
+    }
+}
+
+extension CharacterSet {
+    /// Creates a CharacterSet from RFC 3986 allowed characters.
+    ///
+    /// RFC 3986 states that the following characters are "reserved" characters.
+    ///
+    /// - General Delimiters: ":", "#", "[", "]", "@", "?", "/"
+    /// - Sub-Delimiters: "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "="
+    ///
+    /// In RFC 3986 - Section 3.4, it states that the "?" and "/" characters should not be escaped to allow
+    /// query strings to include a URL. Therefore, all "reserved" characters with the exception of "?" and "/"
+    /// should be percent-escaped in the query string.
+    public static let afURLQueryAllowed: CharacterSet = {
+        let generalDelimitersToEncode = ":#[]@" // does not include "?" or "/" due to RFC 3986 - Section 3.4
+        let subDelimitersToEncode = "!$&'()*+,;="
+        let encodableDelimiters = CharacterSet(charactersIn: "\(generalDelimitersToEncode)\(subDelimitersToEncode)")
+
+        return CharacterSet.urlQueryAllowed.subtracting(encodableDelimiters)
+    }()
+}

Pods/Alamofire/Source/URLRequest+Alamofire.swift

@@ -0,0 +1,39 @@
+//
+//  URLRequest+Alamofire.swift
+//
+//  Copyright (c) 2019 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension URLRequest {
+    /// Returns the `httpMethod` as Alamofire's `HTTPMethod` type.
+    public var method: HTTPMethod? {
+        get { httpMethod.flatMap(HTTPMethod.init) }
+        set { httpMethod = newValue?.rawValue }
+    }
+
+    public func validate() throws {
+        if method == .get, let bodyData = httpBody {
+            throw AFError.urlRequestValidationFailed(reason: .bodyDataInGETRequest(bodyData))
+        }
+    }
+}

Pods/Alamofire/Source/URLSessionConfiguration+Alamofire.swift

@@ -0,0 +1,46 @@
+//
+//  URLSessionConfiguration+Alamofire.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension URLSessionConfiguration: AlamofireExtended {}
+extension AlamofireExtension where ExtendedType: URLSessionConfiguration {
+    /// Alamofire's default configuration. Same as `URLSessionConfiguration.default` but adds Alamofire default
+    /// `Accept-Language`, `Accept-Encoding`, and `User-Agent` headers.
+    public static var `default`: URLSessionConfiguration {
+        let configuration = URLSessionConfiguration.default
+        configuration.headers = .default
+
+        return configuration
+    }
+
+    /// `.ephemeral` configuration with Alamofire's default `Accept-Language`, `Accept-Encoding`, and `User-Agent`
+    /// headers.
+    public static var ephemeral: URLSessionConfiguration {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.headers = .default
+
+        return configuration
+    }
+}

Pods/Alamofire/Source/Validation.swift

@@ -0,0 +1,302 @@
+//
+//  Validation.swift
+//
+//  Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+
+extension Request {
+    // MARK: Helper Types
+
+    fileprivate typealias ErrorReason = AFError.ResponseValidationFailureReason
+
+    /// Used to represent whether a validation succeeded or failed.
+    public typealias ValidationResult = Result<Void, Error>
+
+    fileprivate struct MIMEType {
+        let type: String
+        let subtype: String
+
+        var isWildcard: Bool { type == "*" && subtype == "*" }
+
+        init?(_ string: String) {
+            let components: [String] = {
+                let stripped = string.trimmingCharacters(in: .whitespacesAndNewlines)
+                let split = stripped[..<(stripped.range(of: ";")?.lowerBound ?? stripped.endIndex)]
+
+                return split.components(separatedBy: "/")
+            }()
+
+            if let type = components.first, let subtype = components.last {
+                self.type = type
+                self.subtype = subtype
+            } else {
+                return nil
+            }
+        }
+
+        func matches(_ mime: MIMEType) -> Bool {
+            switch (type, subtype) {
+            case (mime.type, mime.subtype), (mime.type, "*"), ("*", mime.subtype), ("*", "*"):
+                return true
+            default:
+                return false
+            }
+        }
+    }
+
+    // MARK: Properties
+
+    fileprivate var acceptableStatusCodes: Range<Int> { 200..<300 }
+
+    fileprivate var acceptableContentTypes: [String] {
+        if let accept = request?.value(forHTTPHeaderField: "Accept") {
+            return accept.components(separatedBy: ",")
+        }
+
+        return ["*/*"]
+    }
+
+    // MARK: Status Code
+
+    fileprivate func validate<S: Sequence>(statusCode acceptableStatusCodes: S,
+                                           response: HTTPURLResponse)
+        -> ValidationResult
+        where S.Iterator.Element == Int {
+        if acceptableStatusCodes.contains(response.statusCode) {
+            return .success(())
+        } else {
+            let reason: ErrorReason = .unacceptableStatusCode(code: response.statusCode)
+            return .failure(AFError.responseValidationFailed(reason: reason))
+        }
+    }
+
+    // MARK: Content Type
+
+    fileprivate func validate<S: Sequence>(contentType acceptableContentTypes: S,
+                                           response: HTTPURLResponse,
+                                           data: Data?)
+        -> ValidationResult
+        where S.Iterator.Element == String {
+        guard let data = data, !data.isEmpty else { return .success(()) }
+
+        return validate(contentType: acceptableContentTypes, response: response)
+    }
+
+    fileprivate func validate<S: Sequence>(contentType acceptableContentTypes: S,
+                                           response: HTTPURLResponse)
+        -> ValidationResult
+        where S.Iterator.Element == String {
+        guard
+            let responseContentType = response.mimeType,
+            let responseMIMEType = MIMEType(responseContentType)
+        else {
+            for contentType in acceptableContentTypes {
+                if let mimeType = MIMEType(contentType), mimeType.isWildcard {
+                    return .success(())
+                }
+            }
+
+            let error: AFError = {
+                let reason: ErrorReason = .missingContentType(acceptableContentTypes: Array(acceptableContentTypes))
+                return AFError.responseValidationFailed(reason: reason)
+            }()
+
+            return .failure(error)
+        }
+
+        for contentType in acceptableContentTypes {
+            if let acceptableMIMEType = MIMEType(contentType), acceptableMIMEType.matches(responseMIMEType) {
+                return .success(())
+            }
+        }
+
+        let error: AFError = {
+            let reason: ErrorReason = .unacceptableContentType(acceptableContentTypes: Array(acceptableContentTypes),
+                                                               responseContentType: responseContentType)
+
+            return AFError.responseValidationFailed(reason: reason)
+        }()
+
+        return .failure(error)
+    }
+}
+
+// MARK: -
+
+extension DataRequest {
+    /// A closure used to validate a request that takes a URL request, a URL response and data, and returns whether the
+    /// request was valid.
+    public typealias Validation = (URLRequest?, HTTPURLResponse, Data?) -> ValidationResult
+
+    /// Validates that the response has a status code in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Parameter statusCode: `Sequence` of acceptable response status codes.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func validate<S: Sequence>(statusCode acceptableStatusCodes: S) -> Self where S.Iterator.Element == Int {
+        validate { [unowned self] _, response, _ in
+            self.validate(statusCode: acceptableStatusCodes, response: response)
+        }
+    }
+
+    /// Validates that the response has a content type in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
+    ///
+    /// - returns: The request.
+    @discardableResult
+    public func validate<S: Sequence>(contentType acceptableContentTypes: @escaping @autoclosure () -> S) -> Self where S.Iterator.Element == String {
+        validate { [unowned self] _, response, data in
+            self.validate(contentType: acceptableContentTypes(), response: response, data: data)
+        }
+    }
+
+    /// Validates that the response has a status code in the default acceptable range of 200...299, and that the content
+    /// type matches any specified in the Accept HTTP header field.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - returns: The request.
+    @discardableResult
+    public func validate() -> Self {
+        let contentTypes: () -> [String] = { [unowned self] in
+            self.acceptableContentTypes
+        }
+        return validate(statusCode: acceptableStatusCodes).validate(contentType: contentTypes())
+    }
+}
+
+extension DataStreamRequest {
+    /// A closure used to validate a request that takes a `URLRequest` and `HTTPURLResponse` and returns whether the
+    /// request was valid.
+    public typealias Validation = (_ request: URLRequest?, _ response: HTTPURLResponse) -> ValidationResult
+
+    /// Validates that the response has a status code in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Parameter statusCode: `Sequence` of acceptable response status codes.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func validate<S: Sequence>(statusCode acceptableStatusCodes: S) -> Self where S.Iterator.Element == Int {
+        validate { [unowned self] _, response in
+            self.validate(statusCode: acceptableStatusCodes, response: response)
+        }
+    }
+
+    /// Validates that the response has a content type in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
+    ///
+    /// - returns: The request.
+    @discardableResult
+    public func validate<S: Sequence>(contentType acceptableContentTypes: @escaping @autoclosure () -> S) -> Self where S.Iterator.Element == String {
+        validate { [unowned self] _, response in
+            self.validate(contentType: acceptableContentTypes(), response: response)
+        }
+    }
+
+    /// Validates that the response has a status code in the default acceptable range of 200...299, and that the content
+    /// type matches any specified in the Accept HTTP header field.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Returns: The instance.
+    @discardableResult
+    public func validate() -> Self {
+        let contentTypes: () -> [String] = { [unowned self] in
+            self.acceptableContentTypes
+        }
+        return validate(statusCode: acceptableStatusCodes).validate(contentType: contentTypes())
+    }
+}
+
+// MARK: -
+
+extension DownloadRequest {
+    /// A closure used to validate a request that takes a URL request, a URL response, a temporary URL and a
+    /// destination URL, and returns whether the request was valid.
+    public typealias Validation = (_ request: URLRequest?,
+                                   _ response: HTTPURLResponse,
+                                   _ fileURL: URL?)
+        -> ValidationResult
+
+    /// Validates that the response has a status code in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - Parameter statusCode: `Sequence` of acceptable response status codes.
+    ///
+    /// - Returns:              The instance.
+    @discardableResult
+    public func validate<S: Sequence>(statusCode acceptableStatusCodes: S) -> Self where S.Iterator.Element == Int {
+        validate { [unowned self] _, response, _ in
+            self.validate(statusCode: acceptableStatusCodes, response: response)
+        }
+    }
+
+    /// Validates that the response has a content type in the specified sequence.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
+    ///
+    /// - returns: The request.
+    @discardableResult
+    public func validate<S: Sequence>(contentType acceptableContentTypes: @escaping @autoclosure () -> S) -> Self where S.Iterator.Element == String {
+        validate { [unowned self] _, response, fileURL in
+            guard let validFileURL = fileURL else {
+                return .failure(AFError.responseValidationFailed(reason: .dataFileNil))
+            }
+
+            do {
+                let data = try Data(contentsOf: validFileURL)
+                return self.validate(contentType: acceptableContentTypes(), response: response, data: data)
+            } catch {
+                return .failure(AFError.responseValidationFailed(reason: .dataFileReadFailed(at: validFileURL)))
+            }
+        }
+    }
+
+    /// Validates that the response has a status code in the default acceptable range of 200...299, and that the content
+    /// type matches any specified in the Accept HTTP header field.
+    ///
+    /// If validation fails, subsequent calls to response handlers will have an associated error.
+    ///
+    /// - returns: The request.
+    @discardableResult
+    public func validate() -> Self {
+        let contentTypes = { [unowned self] in
+            self.acceptableContentTypes
+        }
+        return validate(statusCode: acceptableStatusCodes).validate(contentType: contentTypes())
+    }
+}

Pods/AppAuth/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Pods/AppAuth/README.md

@@ -0,0 +1,574 @@
+![AppAuth for iOS and macOS](https://rawgit.com/openid/AppAuth-iOS/master/appauth_lockup.svg)
+[![Build Status](https://travis-ci.org/openid/AppAuth-iOS.svg?branch=master)](https://travis-ci.org/openid/AppAuth-iOS)
+[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
+
+AppAuth for iOS and macOS is a client SDK for communicating with 
+[OAuth 2.0](https://tools.ietf.org/html/rfc6749) and 
+[OpenID Connect](http://openid.net/specs/openid-connect-core-1_0.html) providers. 
+It strives to
+directly map the requests and responses of those specifications, while following
+the idiomatic style of the implementation language. In addition to mapping the
+raw protocol flows, convenience methods are available to assist with common
+tasks like performing an action with fresh tokens.
+
+It follows the best practices set out in 
+[RFC 8252 - OAuth 2.0 for Native Apps](https://tools.ietf.org/html/rfc8252)
+including using `SFAuthenticationSession` and `SFSafariViewController` on iOS
+for the auth request. `UIWebView` and `WKWebView` are explicitly *not*
+supported due to the security and usability reasons explained in
+[Section 8.12 of RFC 8252](https://tools.ietf.org/html/rfc8252#section-8.12).
+
+It also supports the [PKCE](https://tools.ietf.org/html/rfc7636) extension to
+OAuth, which was created to secure authorization codes in public clients when
+custom URI scheme redirects are used. The library is friendly to other
+extensions (standard or otherwise), with the ability to handle additional params
+in all protocol requests and responses.
+
+## Specification
+
+### iOS
+
+#### Supported Versions
+
+AppAuth supports iOS 7 and above.
+
+iOS 9+ uses the in-app browser tab pattern
+(via `SFSafariViewController`), and falls back to the system browser (mobile
+Safari) on earlier versions.
+
+#### Authorization Server Requirements
+
+Both Custom URI Schemes (all supported versions of iOS) and Universal Links
+(iOS 9+) can be used with the library.
+
+In general, AppAuth can work with any authorization server that supports
+native apps, as documented in [RFC 8252](https://tools.ietf.org/html/rfc8252),
+either through custom URI scheme redirects, or universal links.
+Authorization servers that assume all clients are web-based, or require clients to maintain
+confidentiality of the client secrets may not work well.
+
+### macOS
+
+#### Supported Versions
+
+AppAuth supports macOS (OS X) 10.9 and above.
+
+#### Authorization Server Requirements
+
+AppAuth for macOS supports both custom schemes; a loopback HTTP redirects
+via a small embedded server.
+
+In general, AppAuth can work with any authorization server that supports
+native apps, as documented in [RFC 8252](https://tools.ietf.org/html/rfc8252);
+either through custom URI schemes, or loopback HTTP redirects.
+Authorization servers that assume all clients are web-based, or require clients to maintain
+confidentiality of the client secrets may not work well.
+
+## Try
+
+Want to try out AppAuth? Just run:
+
+    pod try AppAuth
+
+Follow the instructions in [Examples/README.md](Examples/README.md) to configure
+with your own OAuth client (you need to update three configuration points with your
+client info to try the demo).
+
+## Setup
+
+AppAuth supports four options for dependency management.
+
+### Swift Package Manager
+
+With [Swift Package Manager](https://swift.org/package-manager), 
+add the following `dependency` to your `Package.swift`:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/openid/AppAuth-iOS.git", .upToNextMajor(from: "1.3.0"))
+]
+```
+
+### CocoaPods
+
+With [CocoaPods](https://guides.cocoapods.org/using/getting-started.html),
+add the following line to your `Podfile`:
+
+    pod 'AppAuth'
+
+Then, run `pod install`.
+
+### Carthage
+
+With [Carthage](https://github.com/Carthage/Carthage), add the following
+line to your `Cartfile`:
+
+    github "openid/AppAuth-iOS" "master"
+
+Then, run `carthage bootstrap`.
+
+### Static Library
+
+You can also use AppAuth as a static library. This requires linking the library
+and your project, and including the headers.  Here is a suggested configuration:
+
+1. Create an Xcode Workspace.
+2. Add `AppAuth.xcodeproj` to your Workspace.
+3. Include libAppAuth as a linked library for your target (in the "General ->
+Linked Framework and Libraries" section of your target).
+4. Add `AppAuth-iOS/Source` to your search paths of your target ("Build Settings ->
+"Header Search Paths").
+
+## Auth Flow
+
+AppAuth supports both manual interaction with the authorization server
+where you need to perform your own token exchanges, as well as convenience
+methods that perform some of this logic for you. This example uses the
+convenience method, which returns either an `OIDAuthState` object, or an error.
+
+`OIDAuthState` is a class that keeps track of the authorization and token
+requests and responses, and provides a convenience method to call an API with
+fresh tokens. This is the only object that you need to serialize to retain the
+authorization state of the session.
+
+### Configuration
+
+You can configure AppAuth by specifying the endpoints directly:
+
+<sub>Objective-C</sub>
+```objc
+NSURL *authorizationEndpoint =
+    [NSURL URLWithString:@"https://accounts.google.com/o/oauth2/v2/auth"];
+NSURL *tokenEndpoint =
+    [NSURL URLWithString:@"https://www.googleapis.com/oauth2/v4/token"];
+
+OIDServiceConfiguration *configuration =
+    [[OIDServiceConfiguration alloc]
+        initWithAuthorizationEndpoint:authorizationEndpoint
+                        tokenEndpoint:tokenEndpoint];
+
+// perform the auth request...
+```
+
+<sub>Swift</sub>
+```swift
+let authorizationEndpoint = URL(string: "https://accounts.google.com/o/oauth2/v2/auth")!
+let tokenEndpoint = URL(string: "https://www.googleapis.com/oauth2/v4/token")!
+let configuration = OIDServiceConfiguration(authorizationEndpoint: authorizationEndpoint,
+                                            tokenEndpoint: tokenEndpoint)
+
+// perform the auth request...
+```
+
+Or through discovery:
+
+<sub>Objective-C</sub>
+```objc
+NSURL *issuer = [NSURL URLWithString:@"https://accounts.google.com"];
+
+[OIDAuthorizationService discoverServiceConfigurationForIssuer:issuer
+    completion:^(OIDServiceConfiguration *_Nullable configuration,
+                 NSError *_Nullable error) {
+
+  if (!configuration) {
+    NSLog(@"Error retrieving discovery document: %@",
+          [error localizedDescription]);
+    return;
+  }
+
+  // perform the auth request...
+}];
+```
+
+<sub>Swift</sub>
+```swift
+let issuer = URL(string: "https://accounts.google.com")!
+
+// discovers endpoints
+OIDAuthorizationService.discoverConfiguration(forIssuer: issuer) { configuration, error in
+  guard let config = configuration else {
+    print("Error retrieving discovery document: \(error?.localizedDescription ?? "Unknown error")")
+    return
+  }
+
+  // perform the auth request...
+}
+```
+
+### Authorizing – iOS
+
+First, you need to have a property in your `UIApplicationDelegate`
+implementation to hold the session, in order to continue the authorization flow
+from the redirect. In this example, the implementation of this delegate is
+a class named `AppDelegate`, if your app's application delegate has a different
+name, please update the class name in samples below accordingly.
+
+<sub>Objective-C</sub>
+```objc
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+// property of the app's AppDelegate
+@property(nonatomic, strong, nullable) id<OIDExternalUserAgentSession> currentAuthorizationFlow;
+@end
+```
+
+<sub>Swift</sub>
+```swift
+class AppDelegate: UIResponder, UIApplicationDelegate {
+  // property of the app's AppDelegate
+  var currentAuthorizationFlow: OIDExternalUserAgentSession?
+}
+```
+
+
+And your main class, a property to store the auth state:
+
+<sub>Objective-C</sub>
+```objc
+// property of the containing class
+@property(nonatomic, strong, nullable) OIDAuthState *authState;
+```
+<sub>Swift</sub>
+```swift
+// property of the containing class
+private var authState: OIDAuthState?
+```
+
+
+Then, initiate the authorization request. By using the 
+`authStateByPresentingAuthorizationRequest` convenience method, the token
+exchange will be performed automatically, and everything will be protected with
+PKCE (if the server supports it). AppAuth also lets you perform these
+requests manually. See the `authNoCodeExchange` method in the included Example
+app for a demonstration:
+
+<sub>Objective-C</sub>
+```objc
+// builds authentication request
+OIDAuthorizationRequest *request =
+    [[OIDAuthorizationRequest alloc] initWithConfiguration:configuration
+                                                  clientId:kClientID
+                                                    scopes:@[OIDScopeOpenID,
+                                                             OIDScopeProfile]
+                                               redirectURL:kRedirectURI
+                                              responseType:OIDResponseTypeCode
+                                      additionalParameters:nil];
+
+// performs authentication request
+AppDelegate *appDelegate =
+    (AppDelegate *)[UIApplication sharedApplication].delegate;
+appDelegate.currentAuthorizationFlow =
+    [OIDAuthState authStateByPresentingAuthorizationRequest:request
+        presentingViewController:self
+                        callback:^(OIDAuthState *_Nullable authState,
+                                   NSError *_Nullable error) {
+  if (authState) {
+    NSLog(@"Got authorization tokens. Access token: %@",
+          authState.lastTokenResponse.accessToken);
+    [self setAuthState:authState];
+  } else {
+    NSLog(@"Authorization error: %@", [error localizedDescription]);
+    [self setAuthState:nil];
+  }
+}];
+```
+
+<sub>Swift</sub>
+```swift
+// builds authentication request
+let request = OIDAuthorizationRequest(configuration: configuration,
+                                      clientId: clientID,
+                                      clientSecret: clientSecret,
+                                      scopes: [OIDScopeOpenID, OIDScopeProfile],
+                                      redirectURL: redirectURI,
+                                      responseType: OIDResponseTypeCode,
+                                      additionalParameters: nil)
+
+// performs authentication request
+print("Initiating authorization request with scope: \(request.scope ?? "nil")")
+
+let appDelegate = UIApplication.shared.delegate as! AppDelegate
+
+appDelegate.currentAuthorizationFlow =
+    OIDAuthState.authState(byPresenting: request, presenting: self) { authState, error in
+  if let authState = authState {
+    self.setAuthState(authState)
+    print("Got authorization tokens. Access token: " +
+          "\(authState.lastTokenResponse?.accessToken ?? "nil")")
+  } else {
+    print("Authorization error: \(error?.localizedDescription ?? "Unknown error")")
+    self.setAuthState(nil)
+  }
+}
+```
+
+*Handling the Redirect*
+
+The authorization response URL is returned to the app via the iOS openURL
+app delegate method, so you need to pipe this through to the current
+authorization session (created in the previous session):
+
+<sub>Objective-C</sub>
+```objc
+- (BOOL)application:(UIApplication *)app
+            openURL:(NSURL *)url
+            options:(NSDictionary<NSString *, id> *)options {
+  // Sends the URL to the current authorization flow (if any) which will
+  // process it if it relates to an authorization response.
+  if ([_currentAuthorizationFlow resumeExternalUserAgentFlowWithURL:url]) {
+    _currentAuthorizationFlow = nil;
+    return YES;
+  }
+
+  // Your additional URL handling (if any) goes here.
+
+  return NO;
+}
+```
+
+<sub>Swift</sub>
+```swift
+func application(_ app: UIApplication,
+                 open url: URL,
+                 options: [UIApplicationOpenURLOptionsKey : Any] = [:]) -> Bool {
+  // Sends the URL to the current authorization flow (if any) which will
+  // process it if it relates to an authorization response.
+  if let authorizationFlow = self.currentAuthorizationFlow,
+                             authorizationFlow.resumeExternalUserAgentFlow(with: url) {
+    self.currentAuthorizationFlow = nil
+    return true
+  }
+
+  // Your additional URL handling (if any)
+
+  return false
+}
+```
+
+### Authorizing – MacOS
+
+On macOS, the most popular way to get the authorization response redirect is to
+start a local HTTP server on the loopback interface (limited to incoming
+requests from the user's machine only). When the authorization is complete, the
+user is redirected to that local server, and the authorization response can be
+processed by the app. AppAuth takes care of managing the local HTTP server
+lifecycle for you.
+
+> #### :bulb: Alternative: Custom URI Schemes
+> Custom URI schemes are also supported on macOS, but some browsers display
+> an interstitial, which reduces the usability. For an example on using custom
+> URI schemes with macOS, See `Example-Mac`.
+
+To receive the authorization response using a local HTTP server, first you need
+to have an instance variable in your main class to retain the HTTP redirect
+handler:
+
+<sub>Objective-C</sub>
+```objc
+OIDRedirectHTTPHandler *_redirectHTTPHandler;
+```
+
+Then, as the port used by the local HTTP server varies, you need to start it
+before building the authorization request, in order to get the exact redirect
+URI to use:
+
+<sub>Objective-C</sub>
+```objc
+static NSString *const kSuccessURLString =
+    @"http://openid.github.io/AppAuth-iOS/redirect/";
+NSURL *successURL = [NSURL URLWithString:kSuccessURLString];
+
+// Starts a loopback HTTP redirect listener to receive the code.  This needs to be started first,
+// as the exact redirect URI (including port) must be passed in the authorization request.
+_redirectHTTPHandler = [[OIDRedirectHTTPHandler alloc] initWithSuccessURL:successURL];
+NSURL *redirectURI = [_redirectHTTPHandler startHTTPListener:nil];
+```
+
+Then, initiate the authorization request. By using the 
+`authStateByPresentingAuthorizationRequest` convenience method, the token
+exchange will be performed automatically, and everything will be protected with
+PKCE (if the server supports it). By assigning the return value to the
+`OIDRedirectHTTPHandler`'s `currentAuthorizationFlow`, the authorization will
+continue automatically once the user makes their choice:
+
+```objc
+// builds authentication request
+OIDAuthorizationRequest *request =
+    [[OIDAuthorizationRequest alloc] initWithConfiguration:configuration
+                                                  clientId:kClientID
+                                              clientSecret:kClientSecret
+                                                    scopes:@[ OIDScopeOpenID ]
+                                               redirectURL:redirectURI
+                                              responseType:OIDResponseTypeCode
+                                      additionalParameters:nil];
+// performs authentication request
+__weak __typeof(self) weakSelf = self;
+_redirectHTTPHandler.currentAuthorizationFlow =
+    [OIDAuthState authStateByPresentingAuthorizationRequest:request
+                        callback:^(OIDAuthState *_Nullable authState,
+                                   NSError *_Nullable error) {
+  // Brings this app to the foreground.
+  [[NSRunningApplication currentApplication]
+      activateWithOptions:(NSApplicationActivateAllWindows |
+                           NSApplicationActivateIgnoringOtherApps)];
+
+  // Processes the authorization response.
+  if (authState) {
+    NSLog(@"Got authorization tokens. Access token: %@",
+          authState.lastTokenResponse.accessToken);
+  } else {
+    NSLog(@"Authorization error: %@", error.localizedDescription);
+  }
+  [weakSelf setAuthState:authState];
+}];
+```
+
+### Making API Calls
+
+AppAuth gives you the raw token information, if you need it. However, we
+recommend that users of the `OIDAuthState` convenience wrapper use the provided
+`performActionWithFreshTokens:` method to perform their API calls to avoid
+needing to worry about token freshness:
+
+<sub>Objective-C</sub>
+```objc
+[_authState performActionWithFreshTokens:^(NSString *_Nonnull accessToken,
+                                           NSString *_Nonnull idToken,
+                                           NSError *_Nullable error) {
+  if (error) {
+    NSLog(@"Error fetching fresh tokens: %@", [error localizedDescription]);
+    return;
+  }
+
+  // perform your API request using the tokens
+}];
+```
+
+<sub>Swift</sub>
+```swift
+let userinfoEndpoint = URL(string:"https://openidconnect.googleapis.com/v1/userinfo")!
+self.authState?.performAction() { (accessToken, idToken, error) in
+
+  if error != nil  {
+    print("Error fetching fresh tokens: \(error?.localizedDescription ?? "Unknown error")")
+    return
+  }
+  guard let accessToken = accessToken else {
+    return
+  }
+
+  // Add Bearer token to request
+  var urlRequest = URLRequest(url: userinfoEndpoint)
+  urlRequest.allHTTPHeaderFields = ["Authorization": "Bearer \(accessToken)"]
+
+  // Perform request...
+}
+```
+
+### Custom User-Agents
+
+Each OAuth flow involves presenting an external user-agent to the user, that
+allows them to interact with the OAuth authorization server. Typical examples
+of a user-agent are the user's browser, or an in-app browser tab incarnation
+like `ASWebAuthenticationSession` on iOS.
+
+AppAuth ships with several implementations of an external user-agent out of the
+box, including defaults for iOS and macOS suitable for most cases. The default
+user-agents typically share persistent cookies with the system default browser,
+to improve the chance that the user doesn't need to sign-in all over again.
+
+It is possible to change the user-agent that AppAuth uses, and even write your
+own - all without needing to fork the library.
+
+All implementations of the external user-agent, be they included or created by
+you need to conform to the 
+[`OIDExternalUserAgent`](http://openid.github.io/AppAuth-iOS/docs/latest/protocol_o_i_d_external_user_agent-p.html)
+protocol.
+
+Instances of the `OIDExternalUserAgent`are passed into
+[`OIDAuthState.authStateByPresentingAuthorizationRequest:externalUserAgent:callback`](http://openid.github.io/AppAuth-iOS/docs/latest/interface_o_i_d_auth_state.html#ac762fe2bf95c116f0b437419be211fa1)
+and/or 
+[`OIDAuthorizationService.presentAuthorizationRequest:externalUserAgent:callback:`](http://openid.github.io/AppAuth-iOS/docs/latest/interface_o_i_d_authorization_service.html#ae551f8e6887366a46e49b09b37389b8f)
+rather than using the platform-specific convenience methods (which use the 
+default user-agents for their respective platforms), like 
+[`OIDAuthState.authStateByPresentingAuthorizationRequest:presentingViewController:callback:`](http://openid.github.io/AppAuth-iOS/docs/latest/category_o_i_d_auth_state_07_i_o_s_08.html#ae32fd0732cd3192cd5219f2655a4c85c).
+
+Popular use-cases for writing your own user-agent implementation include needing
+to style the user-agent in ways not supported by AppAuth, and implementing a
+fully custom flow with your own business logic. You can take one of the existing
+implementations as a starting point to copy, rename, and customize to your
+needs.
+
+#### Custom Browser User-Agent
+
+AppAuth for iOS includes a few extra user-agent implementations which you can
+try, or use as a reference for your own implementation. One of them,
+[`OIDExternalUserAgentIOSCustomBrowser`](http://openid.github.io/AppAuth-iOS/docs/latest/interface_o_i_d_external_user_agent_i_o_s_custom_browser.html)
+enables you to use a different browser for authentication, like Chrome for iOS
+or Firefox for iOS.
+
+Here's how to configure AppAuth to use a custom browser using the
+`OIDExternalUserAgentIOSCustomBrowser` user agent:
+
+First, add the following array to your
+[Info.plist](https://github.com/openid/AppAuth-iOS/blob/135f99d2cb4e9d18d310ac2588b905e612461561/Examples/Example-iOS_ObjC/Source/Info.plist#L34)
+(in XCode, right click -> Open As -> Source Code)
+
+```
+    <key>LSApplicationQueriesSchemes</key>
+    <array>
+        <string>googlechromes</string>
+        <string>opera-https</string>
+        <string>firefox</string>
+    </array>
+```
+
+This is required so that AppAuth can test for the browser and open the app store
+if it's not installed (the default behavior of this user-agent). You only need
+to include the URL scheme of the actual browser you intend to use.
+
+<sub>Objective-C</sub>
+```objc
+// performs authentication request
+AppDelegate *appDelegate =
+    (AppDelegate *)[UIApplication sharedApplication].delegate;
+id<OIDExternalUserAgent> userAgent =
+    [OIDExternalUserAgentIOSCustomBrowser CustomBrowserChrome];
+appDelegate.currentAuthorizationFlow =
+    [OIDAuthState authStateByPresentingAuthorizationRequest:request
+        externalUserAgent:self
+                 callback:^(OIDAuthState *_Nullable authState,
+                                   NSError *_Nullable error) {
+  if (authState) {
+    NSLog(@"Got authorization tokens. Access token: %@",
+          authState.lastTokenResponse.accessToken);
+    [self setAuthState:authState];
+  } else {
+    NSLog(@"Authorization error: %@", [error localizedDescription]);
+    [self setAuthState:nil];
+  }
+}];
+```
+
+That's it! With those two changes (which you can try on the included sample),
+AppAuth will use Chrome iOS for the authorization request (and open Chrome in
+the App Store if it's not installed).
+
+⚠️**Note: the `OIDExternalUserAgentIOSCustomBrowser` user-agent is not intended for consumer apps**. It is designed for
+advanced enterprise use-cases where the app developers have greater control over
+the operating environment and have special requirements that require a custom
+browser like Chrome.
+
+You don't need to stop with the included external user agents either! Since the
+[`OIDExternalUserAgent`](http://openid.github.io/AppAuth-iOS/docs/latest/protocol_o_i_d_external_user_agent-p.html)
+protocol is part of AppAuth's public API, you can implement your own versions of
+it. In the above example,
+`userAgent = [OIDExternalUserAgentIOSCustomBrowser CustomBrowserChrome]` would
+be replaced with an instantiation of your user-agent implementation.
+
+## API Documentation
+
+Browse the [API documentation](http://openid.github.io/AppAuth-iOS/docs/latest/annotated.html).
+
+## Included Samples
+
+Sample apps that explore core AppAuth features are available for iOS and macOS; follow the instructions in [Examples/README.md](Examples/README.md) to get started.

Pods/AppAuth/Source/AppAuth.h

@@ -0,0 +1,92 @@
+/*! @file AppAuth.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthState.h"
+#import "OIDAuthStateChangeDelegate.h"
+#import "OIDAuthStateErrorDelegate.h"
+#import "OIDAuthorizationRequest.h"
+#import "OIDAuthorizationResponse.h"
+#import "OIDAuthorizationService.h"
+#import "OIDError.h"
+#import "OIDErrorUtilities.h"
+#import "OIDExternalUserAgent.h"
+#import "OIDExternalUserAgentRequest.h"
+#import "OIDExternalUserAgentSession.h"
+#import "OIDGrantTypes.h"
+#import "OIDIDToken.h"
+#import "OIDRegistrationRequest.h"
+#import "OIDRegistrationResponse.h"
+#import "OIDResponseTypes.h"
+#import "OIDScopes.h"
+#import "OIDScopeUtilities.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDServiceDiscovery.h"
+#import "OIDTokenRequest.h"
+#import "OIDTokenResponse.h"
+#import "OIDTokenUtilities.h"
+#import "OIDURLSessionProvider.h"
+#import "OIDEndSessionRequest.h"
+#import "OIDEndSessionResponse.h"
+
+#if TARGET_OS_TV
+#elif TARGET_OS_WATCH
+#elif TARGET_OS_IOS || TARGET_OS_MACCATALYST
+#import "OIDAuthState+IOS.h"
+#import "OIDAuthorizationService+IOS.h"
+#import "OIDExternalUserAgentIOS.h"
+#import "OIDExternalUserAgentIOSCustomBrowser.h"
+#import "OIDExternalUserAgentCatalyst.h"
+#elif TARGET_OS_MAC
+#import "OIDAuthState+Mac.h"
+#import "OIDAuthorizationService+Mac.h"
+#import "OIDExternalUserAgentMac.h"
+#import "OIDRedirectHTTPHandler.h"
+#else
+#error "Platform Undefined"
+#endif
+
+/*! @mainpage AppAuth for iOS and macOS
+
+    @section introduction Introduction
+
+    AppAuth for iOS and macOS is a client SDK for communicating with [OAuth 2.0]
+    (https://tools.ietf.org/html/rfc6749) and [OpenID Connect]
+    (http://openid.net/specs/openid-connect-core-1_0.html) providers. It strives to
+    directly map the requests and responses of those specifications, while following
+    the idiomatic style of the implementation language. In addition to mapping the
+    raw protocol flows, convenience methods are available to assist with common
+    tasks like performing an action with fresh tokens.
+
+    It follows the best practices set out in 
+    [RFC 8252 - OAuth 2.0 for Native Apps](https://tools.ietf.org/html/rfc8252)
+    including using `SFAuthenticationSession` and `SFSafariViewController` on iOS
+    for the auth request. Web view and `WKWebView` are explicitly *not*
+    supported due to the security and usability reasons explained in
+    [Section 8.12 of RFC 8252](https://tools.ietf.org/html/rfc8252#section-8.12).
+
+    It also supports the [PKCE](https://tools.ietf.org/html/rfc7636) extension to
+    OAuth which was created to secure authorization codes in public clients when
+    custom URI scheme redirects are used. The library is friendly to other
+    extensions (standard or otherwise) with the ability to handle additional params
+    in all protocol requests and responses.
+
+    <b>Homepage</b>: http://openid.github.io/AppAuth-iOS/ <br>
+    <b>API Documentation</b>: http://openid.github.io/AppAuth-iOS/docs/latest <br>
+    <b>Git Repository</b>: https://github.com/openid/AppAuth-iOS <br>
+
+ */

Pods/AppAuth/Source/AppAuth/iOS/OIDAuthState+IOS.h

@@ -0,0 +1,63 @@
+/*! @file OIDAuthState+IOS.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import <UIKit/UIKit.h>
+
+#import "OIDAuthState.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief iOS specific convenience methods for @c OIDAuthState.
+ */
+@interface OIDAuthState (IOS)
+
+/*! @brief Convenience method to create a @c OIDAuthState by presenting an authorization request
+        and performing the authorization code exchange in the case of code flow requests. For
+        the hybrid flow, the caller should validate the id_token and c_hash, then perform the token
+        request (@c OIDAuthorizationService.performTokenRequest:callback:)
+        and update the OIDAuthState with the results (@c
+        OIDAuthState.updateWithTokenResponse:error:).
+    @param authorizationRequest The authorization request to present.
+    @param presentingViewController The view controller from which to present the
+        @c SFSafariViewController. On iOS 13, the window of this UIViewController
+        is used as the ASPresentationAnchor.
+    @param callback The method called when the request has completed or failed.
+    @return A @c OIDExternalUserAgentSession instance which will terminate when it
+        receives a @c OIDExternalUserAgentSession.cancel message, or after processing a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message.
+ */
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                     presentingViewController:(UIViewController *)presentingViewController
+                                     callback:(OIDAuthStateAuthorizationCallback)callback;
+
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                     callback:(OIDAuthStateAuthorizationCallback)callback API_AVAILABLE(ios(11)) API_UNAVAILABLE(macCatalyst)
+    __deprecated_msg("This method will not work on iOS 13. Use "
+        "authStateByPresentingAuthorizationRequest:presentingViewController:callback:");
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDAuthState+IOS.m

@@ -0,0 +1,58 @@
+/*! @file OIDAuthState+IOS.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import "OIDAuthState+IOS.h"
+#import "OIDExternalUserAgentIOS.h"
+#import "OIDExternalUserAgentCatalyst.h"
+
+@implementation OIDAuthState (IOS)
+
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                     presentingViewController:(UIViewController *)presentingViewController
+                                     callback:(OIDAuthStateAuthorizationCallback)callback {
+  id<OIDExternalUserAgent> externalUserAgent;
+#if TARGET_OS_MACCATALYST
+  externalUserAgent = [[OIDExternalUserAgentCatalyst alloc]
+      initWithPresentingViewController:presentingViewController];
+#else // TARGET_OS_MACCATALYST
+  externalUserAgent = [[OIDExternalUserAgentIOS alloc] initWithPresentingViewController:presentingViewController];
+#endif // TARGET_OS_MACCATALYST
+  return [self authStateByPresentingAuthorizationRequest:authorizationRequest
+                                       externalUserAgent:externalUserAgent
+                                                callback:callback];
+}
+
+#if !TARGET_OS_MACCATALYST
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                                  callback:(OIDAuthStateAuthorizationCallback)callback {
+  OIDExternalUserAgentIOS *externalUserAgent = [[OIDExternalUserAgentIOS alloc] init];
+  return [self authStateByPresentingAuthorizationRequest:authorizationRequest
+                                       externalUserAgent:externalUserAgent
+                                                callback:callback];
+}
+#endif // !TARGET_OS_MACCATALYST
+
+@end
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDAuthorizationService+IOS.h

@@ -0,0 +1,50 @@
+/*! @file OIDAuthorizationService+IOS.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import <UIKit/UIKit.h>
+
+#import "OIDAuthorizationService.h"
+#import "OIDExternalUserAgentSession.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Provides iOS specific authorization request handling.
+ */
+@interface OIDAuthorizationService (IOS)
+
+/*! @brief Perform an authorization flow using \SFSafariViewController.
+    @param request The authorization request.
+    @param presentingViewController The view controller from which to present the
+        \SFSafariViewController.
+    @param callback The method called when the request has completed or failed.
+    @return A @c OIDExternalUserAgentSession instance which will terminate when it
+        receives a @c OIDExternalUserAgentSession.cancel message, or after processing a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message.
+ */
++ (id<OIDExternalUserAgentSession>) presentAuthorizationRequest:(OIDAuthorizationRequest *)request
+    presentingViewController:(UIViewController *)presentingViewController
+                    callback:(OIDAuthorizationCallback)callback;
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDAuthorizationService+IOS.m

@@ -0,0 +1,48 @@
+/*! @file OIDAuthorizationService+IOS.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import "OIDAuthorizationService+IOS.h"
+#import "OIDExternalUserAgentIOS.h"
+#import "OIDExternalUserAgentCatalyst.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@implementation OIDAuthorizationService (IOS)
+
++ (id<OIDExternalUserAgentSession>) presentAuthorizationRequest:(OIDAuthorizationRequest *)request
+    presentingViewController:(UIViewController *)presentingViewController
+                    callback:(OIDAuthorizationCallback)callback {
+  id<OIDExternalUserAgent> externalUserAgent;
+#if TARGET_OS_MACCATALYST
+  externalUserAgent = [[OIDExternalUserAgentCatalyst alloc]
+      initWithPresentingViewController:presentingViewController];
+#else // TARGET_OS_MACCATALYST
+  externalUserAgent = [[OIDExternalUserAgentIOS alloc] initWithPresentingViewController:presentingViewController];
+#endif // TARGET_OS_MACCATALYST
+  return [self presentAuthorizationRequest:request externalUserAgent:externalUserAgent callback:callback];
+}
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentCatalyst.h

@@ -0,0 +1,52 @@
+/*! @file OIDExternalUserAgentCatalyst.h
+   @brief AppAuth iOS SDK
+   @copyright
+       Copyright 2019 The AppAuth Authors. All Rights Reserved.
+   @copydetails
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.
+*/
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import <UIKit/UIKit.h>
+
+#import "OIDExternalUserAgent.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief A Catalyst specific external user-agent that uses `ASWebAuthenticationSession` to
+       present the request.
+*/
+API_AVAILABLE(macCatalyst(13)) API_UNAVAILABLE(ios)
+@interface OIDExternalUserAgentCatalyst : NSObject<OIDExternalUserAgent>
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithPresentingViewController:
+ */
+- (nonnull instancetype)init NS_UNAVAILABLE;
+
+/*! @brief The designated initializer.
+    @param presentingViewController The view controller from which to present the
+        \SFSafariViewController.
+ */
+- (nullable instancetype)initWithPresentingViewController:
+    (UIViewController *)presentingViewController
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentCatalyst.m

@@ -0,0 +1,145 @@
+/*! @file OIDExternalUserAgentCatalyst.m
+   @brief AppAuth iOS SDK
+   @copyright
+       Copyright 2019 The AppAuth Authors. All Rights Reserved.
+   @copydetails
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.
+*/
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import "OIDExternalUserAgentCatalyst.h"
+
+#import <SafariServices/SafariServices.h>
+#import <AuthenticationServices/AuthenticationServices.h>
+
+#import "OIDErrorUtilities.h"
+#import "OIDExternalUserAgentSession.h"
+#import "OIDExternalUserAgentRequest.h"
+
+#if TARGET_OS_MACCATALYST
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OIDExternalUserAgentCatalyst ()<ASWebAuthenticationPresentationContextProviding>
+@end
+
+@implementation OIDExternalUserAgentCatalyst {
+  UIViewController *_presentingViewController;
+
+  BOOL _externalUserAgentFlowInProgress;
+  __weak id<OIDExternalUserAgentSession> _session;
+  ASWebAuthenticationSession *_webAuthenticationVC;
+}
+
+- (nullable instancetype)initWithPresentingViewController:
+    (UIViewController *)presentingViewController {
+  self = [super init];
+  if (self) {
+    _presentingViewController = presentingViewController;
+  }
+  return self;
+}
+
+- (BOOL)presentExternalUserAgentRequest:(id<OIDExternalUserAgentRequest>)request
+                                session:(id<OIDExternalUserAgentSession>)session {
+  if (_externalUserAgentFlowInProgress) {
+    // TODO: Handle errors as authorization is already in progress.
+    return NO;
+  }
+
+  _externalUserAgentFlowInProgress = YES;
+  _session = session;
+  BOOL openedUserAgent = NO;
+  NSURL *requestURL = [request externalUserAgentRequestURL];
+
+  __weak OIDExternalUserAgentCatalyst *weakSelf = self;
+  NSString *redirectScheme = request.redirectScheme;
+  ASWebAuthenticationSession *authenticationVC =
+      [[ASWebAuthenticationSession alloc] initWithURL:requestURL
+                                    callbackURLScheme:redirectScheme
+                                    completionHandler:^(NSURL * _Nullable callbackURL,
+                                                        NSError * _Nullable error) {
+    __strong OIDExternalUserAgentCatalyst *strongSelf = weakSelf;
+    if (!strongSelf) {
+        return;
+    }
+    strongSelf->_webAuthenticationVC = nil;
+    if (callbackURL) {
+      [strongSelf->_session resumeExternalUserAgentFlowWithURL:callbackURL];
+    } else {
+      NSError *safariError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                           underlyingError:error
+                               description:nil];
+      [strongSelf->_session failExternalUserAgentFlowWithError:safariError];
+    }
+  }];
+      
+  authenticationVC.presentationContextProvider = self;
+  _webAuthenticationVC = authenticationVC;
+  openedUserAgent = [authenticationVC start];
+
+  if (!openedUserAgent) {
+    [self cleanUp];
+    NSError *safariError = [OIDErrorUtilities errorWithCode:OIDErrorCodeSafariOpenError
+                                            underlyingError:nil
+                                                description:@"Unable to open ASWebAuthenticationSession view controller."];
+    [session failExternalUserAgentFlowWithError:safariError];
+  }
+  return openedUserAgent;
+}
+
+- (void)dismissExternalUserAgentAnimated:(BOOL)animated completion:(void (^)(void))completion {
+  if (!_externalUserAgentFlowInProgress) {
+    // Ignore this call if there is no authorization flow in progress.
+    if (completion) completion();
+    return;
+  }
+  
+  ASWebAuthenticationSession *webAuthenticationVC = _webAuthenticationVC;
+  
+  [self cleanUp];
+  
+  if (webAuthenticationVC) {
+    // dismiss the ASWebAuthenticationSession
+    [webAuthenticationVC cancel];
+    if (completion) completion();
+  } else {
+    if (completion) completion();
+  }
+}
+
+- (void)cleanUp {
+  // The weak reference to |_session| is set to nil to avoid accidentally using
+  // it while not in an authorization flow.
+  _webAuthenticationVC = nil;
+  _session = nil;
+  _externalUserAgentFlowInProgress = NO;
+}
+
+#pragma mark - ASWebAuthenticationPresentationContextProviding
+
+- (ASPresentationAnchor)presentationAnchorForWebAuthenticationSession:(ASWebAuthenticationSession *)session {
+  return _presentingViewController.view.window;
+}
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_MACCATALYST
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentIOS.h

@@ -0,0 +1,53 @@
+/*! @file OIDExternalUserAgentIOS.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import <UIKit/UIKit.h>
+
+#import "OIDExternalUserAgent.h"
+
+@class SFSafariViewController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief An iOS specific external user-agent that uses the best possible user-agent available
+        depending on the version of iOS to present the request.
+ */
+API_UNAVAILABLE(macCatalyst)
+@interface OIDExternalUserAgentIOS : NSObject<OIDExternalUserAgent>
+
+- (nullable instancetype)init API_AVAILABLE(ios(11))
+    __deprecated_msg("This method will not work on iOS 13, use "
+                     "initWithPresentingViewController:presentingViewController");
+
+/*! @brief The designated initializer.
+    @param presentingViewController The view controller from which to present the
+        \SFSafariViewController.
+ */
+- (nullable instancetype)initWithPresentingViewController:
+    (UIViewController *)presentingViewController
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentIOS.m

@@ -0,0 +1,256 @@
+/*! @file OIDExternalUserAgentIOS.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import "OIDExternalUserAgentIOS.h"
+
+#import <SafariServices/SafariServices.h>
+#import <AuthenticationServices/AuthenticationServices.h>
+
+#import "OIDErrorUtilities.h"
+#import "OIDExternalUserAgentSession.h"
+#import "OIDExternalUserAgentRequest.h"
+
+#if !TARGET_OS_MACCATALYST
+
+NS_ASSUME_NONNULL_BEGIN
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+@interface OIDExternalUserAgentIOS ()<SFSafariViewControllerDelegate, ASWebAuthenticationPresentationContextProviding>
+@end
+#else
+@interface OIDExternalUserAgentIOS ()<SFSafariViewControllerDelegate>
+@end
+#endif
+
+@implementation OIDExternalUserAgentIOS {
+  UIViewController *_presentingViewController;
+
+  BOOL _externalUserAgentFlowInProgress;
+  __weak id<OIDExternalUserAgentSession> _session;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpartial-availability"
+  __weak SFSafariViewController *_safariVC;
+  SFAuthenticationSession *_authenticationVC;
+  ASWebAuthenticationSession *_webAuthenticationVC;
+#pragma clang diagnostic pop
+}
+
+- (nullable instancetype)init {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnonnull"
+  return [self initWithPresentingViewController:nil];
+#pragma clang diagnostic pop
+}
+
+- (nullable instancetype)initWithPresentingViewController:
+    (UIViewController *)presentingViewController {
+  self = [super init];
+  if (self) {
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+    NSAssert(presentingViewController != nil,
+             @"presentingViewController cannot be nil on iOS 13");
+#endif // __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+    
+    _presentingViewController = presentingViewController;
+  }
+  return self;
+}
+
+- (BOOL)presentExternalUserAgentRequest:(id<OIDExternalUserAgentRequest>)request
+                                session:(id<OIDExternalUserAgentSession>)session {
+  if (_externalUserAgentFlowInProgress) {
+    // TODO: Handle errors as authorization is already in progress.
+    return NO;
+  }
+
+  _externalUserAgentFlowInProgress = YES;
+  _session = session;
+  BOOL openedUserAgent = NO;
+  NSURL *requestURL = [request externalUserAgentRequestURL];
+
+  // iOS 12 and later, use ASWebAuthenticationSession
+  if (@available(iOS 12.0, *)) {
+    // ASWebAuthenticationSession doesn't work with guided access (rdar://40809553)
+    if (!UIAccessibilityIsGuidedAccessEnabled()) {
+      __weak OIDExternalUserAgentIOS *weakSelf = self;
+      NSString *redirectScheme = request.redirectScheme;
+      ASWebAuthenticationSession *authenticationVC =
+          [[ASWebAuthenticationSession alloc] initWithURL:requestURL
+                                        callbackURLScheme:redirectScheme
+                                        completionHandler:^(NSURL * _Nullable callbackURL,
+                                                            NSError * _Nullable error) {
+        __strong OIDExternalUserAgentIOS *strongSelf = weakSelf;
+        if (!strongSelf) {
+            return;
+        }
+        strongSelf->_webAuthenticationVC = nil;
+        if (callbackURL) {
+          [strongSelf->_session resumeExternalUserAgentFlowWithURL:callbackURL];
+        } else {
+          NSError *safariError =
+              [OIDErrorUtilities errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                               underlyingError:error
+                                   description:nil];
+          [strongSelf->_session failExternalUserAgentFlowWithError:safariError];
+        }
+      }];
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+      if (@available(iOS 13.0, *)) {
+          authenticationVC.presentationContextProvider = self;
+      }
+#endif
+      _webAuthenticationVC = authenticationVC;
+      openedUserAgent = [authenticationVC start];
+    }
+  }
+  // iOS 11, use SFAuthenticationSession
+  if (@available(iOS 11.0, *)) {
+    // SFAuthenticationSession doesn't work with guided access (rdar://40809553)
+    if (!openedUserAgent && !UIAccessibilityIsGuidedAccessEnabled()) {
+      __weak OIDExternalUserAgentIOS *weakSelf = self;
+      NSString *redirectScheme = request.redirectScheme;
+      SFAuthenticationSession *authenticationVC =
+          [[SFAuthenticationSession alloc] initWithURL:requestURL
+                                     callbackURLScheme:redirectScheme
+                                     completionHandler:^(NSURL * _Nullable callbackURL,
+                                                         NSError * _Nullable error) {
+        __strong OIDExternalUserAgentIOS *strongSelf = weakSelf;
+        if (!strongSelf) {
+            return;
+        }
+        strongSelf->_authenticationVC = nil;
+        if (callbackURL) {
+          [strongSelf->_session resumeExternalUserAgentFlowWithURL:callbackURL];
+        } else {
+          NSError *safariError =
+              [OIDErrorUtilities errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                               underlyingError:error
+                                   description:@"User cancelled."];
+          [strongSelf->_session failExternalUserAgentFlowWithError:safariError];
+        }
+      }];
+      _authenticationVC = authenticationVC;
+      openedUserAgent = [authenticationVC start];
+    }
+  }
+  // iOS 9 and 10, use SFSafariViewController
+  if (@available(iOS 9.0, *)) {
+    if (!openedUserAgent && _presentingViewController) {
+      SFSafariViewController *safariVC =
+          [[SFSafariViewController alloc] initWithURL:requestURL];
+      safariVC.delegate = self;
+      _safariVC = safariVC;
+      [_presentingViewController presentViewController:safariVC animated:YES completion:nil];
+      openedUserAgent = YES;
+    }
+  }
+  // iOS 8 and earlier, use mobile Safari
+  if (!openedUserAgent){
+    openedUserAgent = [[UIApplication sharedApplication] openURL:requestURL];
+  }
+
+  if (!openedUserAgent) {
+    [self cleanUp];
+    NSError *safariError = [OIDErrorUtilities errorWithCode:OIDErrorCodeSafariOpenError
+                                            underlyingError:nil
+                                                description:@"Unable to open Safari."];
+    [session failExternalUserAgentFlowWithError:safariError];
+  }
+  return openedUserAgent;
+}
+
+- (void)dismissExternalUserAgentAnimated:(BOOL)animated completion:(void (^)(void))completion {
+  if (!_externalUserAgentFlowInProgress) {
+    // Ignore this call if there is no authorization flow in progress.
+    if (completion) completion();
+    return;
+  }
+  
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpartial-availability"
+  SFSafariViewController *safariVC = _safariVC;
+  SFAuthenticationSession *authenticationVC = _authenticationVC;
+  ASWebAuthenticationSession *webAuthenticationVC = _webAuthenticationVC;
+#pragma clang diagnostic pop
+  
+  [self cleanUp];
+  
+  if (webAuthenticationVC) {
+    // dismiss the ASWebAuthenticationSession
+    [webAuthenticationVC cancel];
+    if (completion) completion();
+  } else if (authenticationVC) {
+    // dismiss the SFAuthenticationSession
+    [authenticationVC cancel];
+    if (completion) completion();
+  } else if (safariVC) {
+    // dismiss the SFSafariViewController
+    [safariVC dismissViewControllerAnimated:YES completion:completion];
+  } else {
+    if (completion) completion();
+  }
+}
+
+- (void)cleanUp {
+  // The weak references to |_safariVC| and |_session| are set to nil to avoid accidentally using
+  // them while not in an authorization flow.
+  _safariVC = nil;
+  _authenticationVC = nil;
+  _webAuthenticationVC = nil;
+  _session = nil;
+  _externalUserAgentFlowInProgress = NO;
+}
+
+#pragma mark - SFSafariViewControllerDelegate
+
+- (void)safariViewControllerDidFinish:(SFSafariViewController *)controller NS_AVAILABLE_IOS(9.0) {
+  if (controller != _safariVC) {
+    // Ignore this call if the safari view controller do not match.
+    return;
+  }
+  if (!_externalUserAgentFlowInProgress) {
+    // Ignore this call if there is no authorization flow in progress.
+    return;
+  }
+  id<OIDExternalUserAgentSession> session = _session;
+  [self cleanUp];
+  NSError *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                                    underlyingError:nil
+                                        description:@"No external user agent flow in progress."];
+  [session failExternalUserAgentFlowWithError:error];
+}
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+#pragma mark - ASWebAuthenticationPresentationContextProviding
+
+- (ASPresentationAnchor)presentationAnchorForWebAuthenticationSession:(ASWebAuthenticationSession *)session API_AVAILABLE(ios(13.0)){
+  return _presentingViewController.view.window;
+}
+#endif // __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // !TARGET_OS_MACCATALYST
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentIOSCustomBrowser.h

@@ -0,0 +1,113 @@
+/*! @file OIDExternalUserAgentIOSCustomBrowser.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2018 Google LLC
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import <Foundation/Foundation.h>
+
+#import "OIDExternalUserAgent.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief A block that transforms a regular http/https URL into one that will open in an
+        alternative browser.
+    @param requestURL the http/https request URL to be transformed.
+    @return transformed URL.
+ */
+typedef NSURL *_Nullable (^OIDCustomBrowserURLTransformation)(NSURL *_Nullable requestURL);
+
+/*! @brief An implementation of the OIDExternalUserAgent protocol for iOS that uses
+        a custom browser (i.e. not Safari) for external requests. It is suitable for browsers that
+        offer a custom url scheme that simply replaces the "https" scheme. It is not designed
+        for browsers that require other modifications to the URL.  If the browser is not installed
+        the user will be prompted to install it.
+ */
+API_UNAVAILABLE(macCatalyst)
+@interface OIDExternalUserAgentIOSCustomBrowser : NSObject<OIDExternalUserAgent>
+
+/*! @brief URL transformation block for the browser.
+ */
+@property(nonatomic, readonly) OIDCustomBrowserURLTransformation URLTransformation;
+
+/*! @brief URL Scheme used to test for whether the browser is installed.
+ */
+@property(nonatomic, readonly, nullable) NSString *canOpenURLScheme;
+
+/*! @brief URL of the browser's App Store listing.
+ */
+@property(nonatomic, readonly, nullable) NSURL *appStoreURL;
+
+/*! @brief An instance of @c OIDExternalUserAgentIOSCustomBrowser for Chrome.
+ */
++ (instancetype)CustomBrowserChrome;
+
+/*! @brief An instance of @c OIDExternalUserAgentIOSCustomBrowser for Firefox.
+ */
++ (instancetype)CustomBrowserFirefox;
+
+/*! @brief An instance of @c OIDExternalUserAgentIOSCustomBrowser for Opera.
+ */
++ (instancetype)CustomBrowserOpera;
+
+/*! @brief An instance of @c OIDExternalUserAgentIOSCustomBrowser for Safari.
+ */
++ (instancetype)CustomBrowserSafari;
+
+/*! @brief Creates a @c OIDCustomBrowserURLTransformation using the scheme substitution method used
+        iOS browsers like Chrome and Firefox.
+ */
++ (OIDCustomBrowserURLTransformation)
+    URLTransformationSchemeSubstitutionHTTPS:(NSString *)browserSchemeHTTPS
+                                        HTTP:(nullable NSString *)browserSchemeHTTP;
+
+/*! @brief Creates a @c OIDCustomBrowserURLTransformation with the URL prefix method used by
+        iOS browsers like Firefox.
+ */
++ (OIDCustomBrowserURLTransformation) URLTransformationSchemeConcatPrefix:(NSString*)URLprefix;
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithURLTransformation:canOpenURLScheme:appStoreURL:
+ */
+- (nonnull instancetype)init NS_UNAVAILABLE;
+
+/*! @brief OIDExternalUserAgent for a custom browser. @c presentExternalUserAgentRequest:session method
+        will return NO if the browser isn't installed.
+ */
+- (nullable instancetype)initWithURLTransformation:(OIDCustomBrowserURLTransformation)URLTransformation;
+
+/*! @brief The designated initializer.
+    @param URLTransformation the transformation block to translate the URL into one that will open
+        in the desired custom browser.
+    @param canOpenURLScheme any scheme supported by the browser used to check if the browser is
+        installed.
+    @param appStoreURL URL of the browser in the app store. When this and @c canOpenURLScheme
+        are non-nil, @c presentExternalUserAgentRequest:session will redirect the user to the app store
+        if the browser is not installed.
+ */
+- (nullable instancetype)initWithURLTransformation:(OIDCustomBrowserURLTransformation)URLTransformation
+                                  canOpenURLScheme:(nullable NSString *)canOpenURLScheme
+                                       appStoreURL:(nullable NSURL *)appStoreURL
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuth/iOS/OIDExternalUserAgentIOSCustomBrowser.m

@@ -0,0 +1,171 @@
+/*! @file OIDExternalUserAgentIOSCustomBrowser.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2018 Google LLC
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <TargetConditionals.h>
+
+#if TARGET_OS_IOS || TARGET_OS_MACCATALYST
+
+#import "OIDExternalUserAgentIOSCustomBrowser.h"
+
+#import <UIKit/UIKit.h>
+
+#import "OIDAuthorizationRequest.h"
+#import "OIDAuthorizationService.h"
+#import "OIDErrorUtilities.h"
+#import "OIDURLQueryComponent.h"
+
+#if !TARGET_OS_MACCATALYST
+
+NS_ASSUME_NONNULL_BEGIN
+
+@implementation OIDExternalUserAgentIOSCustomBrowser
+
++ (instancetype)CustomBrowserChrome {
+  // Chrome iOS documentation: https://developer.chrome.com/multidevice/ios/links
+  OIDCustomBrowserURLTransformation transform = [[self class] URLTransformationSchemeSubstitutionHTTPS:@"googlechromes" HTTP:@"googlechrome"];
+  NSURL *appStoreURL =
+  [NSURL URLWithString:@"itms-apps://itunes.apple.com/us/app/chrome/id535886823"];
+  return [[[self class] alloc] initWithURLTransformation:transform
+                                        canOpenURLScheme:@"googlechromes"
+                                             appStoreURL:appStoreURL];
+}
+
++ (instancetype)CustomBrowserFirefox {
+  // Firefox iOS documentation: https://github.com/mozilla-mobile/firefox-ios-open-in-client
+  OIDCustomBrowserURLTransformation transform =
+      [[self class] URLTransformationSchemeConcatPrefix:@"firefox://open-url?url="];
+  NSURL *appStoreURL =
+  [NSURL URLWithString:@"itms-apps://itunes.apple.com/us/app/firefox-web-browser/id989804926"];
+  return [[[self class] alloc] initWithURLTransformation:transform
+                                        canOpenURLScheme:@"firefox"
+                                             appStoreURL:appStoreURL];
+}
+
++ (instancetype)CustomBrowserOpera {
+  OIDCustomBrowserURLTransformation transform =
+      [[self class] URLTransformationSchemeSubstitutionHTTPS:@"opera-https" HTTP:@"opera-http"];
+  NSURL *appStoreURL =
+  [NSURL URLWithString:@"itms-apps://itunes.apple.com/us/app/opera-mini-web-browser/id363729560"];
+  return [[[self class] alloc] initWithURLTransformation:transform
+                                        canOpenURLScheme:@"opera-https"
+                                             appStoreURL:appStoreURL];
+}
+
++ (instancetype)CustomBrowserSafari {
+  OIDCustomBrowserURLTransformation transformNOP = ^NSURL *(NSURL *requestURL) {
+    return requestURL;
+  };
+  OIDExternalUserAgentIOSCustomBrowser *transform =
+      [[[self class] alloc] initWithURLTransformation:transformNOP];
+  return transform;
+}
+
++ (OIDCustomBrowserURLTransformation)
+    URLTransformationSchemeSubstitutionHTTPS:(NSString *)browserSchemeHTTPS
+                                        HTTP:(nullable NSString *)browserSchemeHTTP {
+  OIDCustomBrowserURLTransformation transform = ^NSURL *(NSURL *requestURL) {
+    // Replace the URL Scheme with the Chrome equivalent.
+    NSString *newScheme = nil;
+    if ([requestURL.scheme isEqualToString:@"https"]) {
+      newScheme = browserSchemeHTTPS;
+    } else if ([requestURL.scheme isEqualToString:@"http"]) {
+      if (!browserSchemeHTTP) {
+        NSAssert(false, @"No HTTP scheme registered for browser");
+        return nil;
+      }
+      newScheme = browserSchemeHTTP;
+    }
+     
+    // Replaces the URI scheme with the custom scheme
+    NSURLComponents *components = [NSURLComponents componentsWithURL:requestURL
+                                             resolvingAgainstBaseURL:YES];
+    components.scheme = newScheme;
+    return components.URL;
+  };
+  return transform;
+}
+
++ (OIDCustomBrowserURLTransformation)URLTransformationSchemeConcatPrefix:(NSString *)URLprefix {
+  OIDCustomBrowserURLTransformation transform = ^NSURL *(NSURL *requestURL) {
+    NSString *requestURLString = [requestURL absoluteString];
+    NSMutableCharacterSet *allowedParamCharacters =
+        [OIDURLQueryComponent URLParamValueAllowedCharacters];
+    NSString *encodedUrl = [requestURLString stringByAddingPercentEncodingWithAllowedCharacters:allowedParamCharacters];
+    NSString *newURL = [NSString stringWithFormat:@"%@%@", URLprefix, encodedUrl];
+    return [NSURL URLWithString:newURL];
+  };
+  return transform;
+}
+
+- (nullable instancetype)initWithURLTransformation:
+    (OIDCustomBrowserURLTransformation)URLTransformation {
+  return [self initWithURLTransformation:URLTransformation canOpenURLScheme:nil appStoreURL:nil];
+}
+
+- (nullable instancetype)
+    initWithURLTransformation:(OIDCustomBrowserURLTransformation)URLTransformation
+             canOpenURLScheme:(nullable NSString *)canOpenURLScheme
+                  appStoreURL:(nullable NSURL *)appStoreURL {
+  self = [super init];
+  if (self) {
+    _URLTransformation = URLTransformation;
+    _canOpenURLScheme = canOpenURLScheme;
+    _appStoreURL = appStoreURL;
+  }
+  return self;
+}
+
+- (BOOL)presentExternalUserAgentRequest:(nonnull id<OIDExternalUserAgentRequest>)request
+                                session:(nonnull id<OIDExternalUserAgentSession>)session {
+  // If the app store URL is set, checks if the app is installed and if not opens the app store.
+  if (_appStoreURL && _canOpenURLScheme) {
+    // Verifies existence of LSApplicationQueriesSchemes Info.plist key.
+    NSArray __unused* canOpenURLs =
+        [[NSBundle mainBundle] objectForInfoDictionaryKey:@"LSApplicationQueriesSchemes"];
+    NSAssert(canOpenURLs, @"plist missing LSApplicationQueriesSchemes key");
+    NSAssert1([canOpenURLs containsObject:_canOpenURLScheme],
+              @"plist missing LSApplicationQueriesSchemes entry for '%@'", _canOpenURLScheme);
+
+    // Opens AppStore if app isn't installed
+    NSString *testURLString = [NSString stringWithFormat:@"%@://example.com", _canOpenURLScheme];
+    NSURL *testURL = [NSURL URLWithString:testURLString];
+    if (![[UIApplication sharedApplication] canOpenURL:testURL]) {
+      [[UIApplication sharedApplication] openURL:_appStoreURL];
+      return NO;
+    }
+  }
+  
+  // Transforms the request URL and opens it.
+  NSURL *requestURL = [request externalUserAgentRequestURL];
+  requestURL = _URLTransformation(requestURL);
+  BOOL openedInBrowser = [[UIApplication sharedApplication] openURL:requestURL];
+  return openedInBrowser;
+}
+
+- (void)dismissExternalUserAgentAnimated:(BOOL)animated
+                                completion:(nonnull void (^)(void))completion {
+  completion();
+}
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // !TARGET_OS_MACCATALYST
+
+#endif // TARGET_OS_IOS || TARGET_OS_MACCATALYST

Pods/AppAuth/Source/AppAuthCore.h

@@ -0,0 +1,44 @@
+/*! @file AppAuthCore.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthState.h"
+#import "OIDAuthStateChangeDelegate.h"
+#import "OIDAuthStateErrorDelegate.h"
+#import "OIDAuthorizationRequest.h"
+#import "OIDAuthorizationResponse.h"
+#import "OIDAuthorizationService.h"
+#import "OIDError.h"
+#import "OIDErrorUtilities.h"
+#import "OIDExternalUserAgent.h"
+#import "OIDExternalUserAgentRequest.h"
+#import "OIDExternalUserAgentSession.h"
+#import "OIDGrantTypes.h"
+#import "OIDIDToken.h"
+#import "OIDRegistrationRequest.h"
+#import "OIDRegistrationResponse.h"
+#import "OIDResponseTypes.h"
+#import "OIDScopes.h"
+#import "OIDScopeUtilities.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDServiceDiscovery.h"
+#import "OIDTokenRequest.h"
+#import "OIDTokenResponse.h"
+#import "OIDTokenUtilities.h"
+#import "OIDURLSessionProvider.h"
+#import "OIDEndSessionRequest.h"
+#import "OIDEndSessionResponse.h"

Pods/AppAuth/Source/AppAuthCore/OIDAuthState.h

@@ -0,0 +1,272 @@
+/*! @file OIDAuthState.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+#import <Foundation/Foundation.h>
+
+@class OIDAuthorizationRequest;
+@class OIDAuthorizationResponse;
+@class OIDAuthState;
+@class OIDRegistrationResponse;
+@class OIDTokenResponse;
+@class OIDTokenRequest;
+@protocol OIDAuthStateChangeDelegate;
+@protocol OIDAuthStateErrorDelegate;
+@protocol OIDExternalUserAgent;
+@protocol OIDExternalUserAgentSession;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents a block used to call an action with a fresh access token.
+    @param accessToken A valid access token if available.
+    @param idToken A valid ID token if available.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDAuthStateAction)(NSString *_Nullable accessToken,
+                                   NSString *_Nullable idToken,
+                                   NSError *_Nullable error);
+
+/*! @brief The method called when the @c
+        OIDAuthState.authStateByPresentingAuthorizationRequest:presentingViewController:callback:
+        method has completed or failed.
+    @param authState The auth state, if the authorization request succeeded.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDAuthStateAuthorizationCallback)(OIDAuthState *_Nullable authState,
+                                                  NSError *_Nullable error);
+
+/*! @brief A convenience class that retains the auth state between @c OIDAuthorizationResponse%s
+        and @c OIDTokenResponse%s.
+ */
+@interface OIDAuthState : NSObject <NSSecureCoding>
+
+/*! @brief The most recent refresh token received from the server.
+    @discussion Rather than using this property directly, you should call
+        @c OIDAuthState.performActionWithFreshTokens:.
+    @remarks refresh_token
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *refreshToken;
+
+/*! @brief The scope of the current authorization grant.
+    @discussion This represents the latest scope returned by the server and may be a subset of the
+        scope that was initially granted.
+    @remarks scope
+ */
+@property(nonatomic, readonly, nullable) NSString *scope;
+
+/*! @brief The most recent authorization response used to update the authorization state. For the
+        implicit flow, this will contain the latest access token.
+ */
+@property(nonatomic, readonly) OIDAuthorizationResponse *lastAuthorizationResponse;
+
+/*! @brief The most recent token response used to update this authorization state. This will
+        contain the latest access token.
+ */
+@property(nonatomic, readonly, nullable) OIDTokenResponse *lastTokenResponse;
+
+/*! @brief The most recent registration response used to update this authorization state. This will
+        contain the latest client credentials.
+ */
+@property(nonatomic, readonly, nullable) OIDRegistrationResponse *lastRegistrationResponse;
+
+/*! @brief The authorization error that invalidated this @c OIDAuthState.
+    @discussion The authorization error encountered by @c OIDAuthState or set by the user via
+        @c OIDAuthState.updateWithAuthorizationError: that invalidated this @c OIDAuthState.
+        Authorization errors from @c OIDAuthState will always have a domain of
+        @c ::OIDOAuthAuthorizationErrorDomain or @c ::OIDOAuthTokenErrorDomain. Note: that after
+        unarchiving the @c OIDAuthState object, the \NSError_userInfo property of this error will
+        be nil.
+ */
+@property(nonatomic, readonly, nullable) NSError *authorizationError;
+
+/*! @brief Returns YES if the authorization state is not known to be invalid.
+    @discussion Returns YES if no OAuth errors have been received, and the last call resulted in a
+        successful access token or id token. This does not mean that the access is fresh - just
+        that it was valid the last time it was used. Note that network and other transient errors
+        do not invalidate the authorized state.  If NO, you should authenticate the user again,
+        using a fresh authorization request. Invalid @c OIDAuthState objects may still be useful in
+        that case, to hint at the previously authorized user and streamline the re-authentication
+        experience.
+ */
+@property(nonatomic, readonly) BOOL isAuthorized;
+
+/*! @brief The @c OIDAuthStateChangeDelegate delegate.
+    @discussion Use the delegate to observe state changes (and update storage) as well as error
+        states.
+ */
+@property(nonatomic, weak, nullable) id<OIDAuthStateChangeDelegate> stateChangeDelegate;
+
+/*! @brief The @c OIDAuthStateErrorDelegate delegate.
+    @discussion Use the delegate to observe state changes (and update storage) as well as error
+        states.
+ */
+@property(nonatomic, weak, nullable) id<OIDAuthStateErrorDelegate> errorDelegate;
+
+/*! @brief Convenience method to create a @c OIDAuthState by presenting an authorization request
+        and performing the authorization code exchange in the case of code flow requests. For
+        the hybrid flow, the caller should validate the id_token and c_hash, then perform the token
+        request (@c OIDAuthorizationService.performTokenRequest:callback:)
+        and update the OIDAuthState with the results (@c
+        OIDAuthState.updateWithTokenResponse:error:).
+    @param authorizationRequest The authorization request to present.
+    @param externalUserAgent A external user agent that can present an external user-agent request.
+    @param callback The method called when the request has completed or failed.
+    @return A @c OIDExternalUserAgentSession instance which will terminate when it
+        receives a @c OIDExternalUserAgentSession.cancel message, or after processing a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message.
+ */
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                            externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                                     callback:(OIDAuthStateAuthorizationCallback)callback;
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithAuthorizationResponse:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Creates an auth state from an authorization response.
+    @param authorizationResponse The authorization response.
+ */
+- (instancetype)initWithAuthorizationResponse:(OIDAuthorizationResponse *)authorizationResponse;
+
+/*! @brief Creates an auth state from an authorization and token response.
+    @param authorizationResponse The authorization response.
+    @param tokenResponse The token response.
+ */
+- (instancetype)initWithAuthorizationResponse:(OIDAuthorizationResponse *)authorizationResponse
+                                tokenResponse:(nullable OIDTokenResponse *)tokenResponse;
+
+/*! @brief Creates an auth state from an registration response.
+    @param registrationResponse The registration response.
+ */
+- (instancetype)initWithRegistrationResponse:(OIDRegistrationResponse *)registrationResponse;
+
+/*! @brief Creates an auth state from an authorization, token and registration response.
+    @param authorizationResponse The authorization response.
+    @param tokenResponse The token response.
+    @param registrationResponse The registration response.
+ */
+- (instancetype)initWithAuthorizationResponse:
+    (nullable OIDAuthorizationResponse *)authorizationResponse
+           tokenResponse:(nullable OIDTokenResponse *)tokenResponse
+    registrationResponse:(nullable OIDRegistrationResponse *)registrationResponse
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Updates the authorization state based on a new authorization response.
+    @param authorizationResponse The new authorization response to update the state with.
+    @param error Any error encountered when performing the authorization request. Errors in the
+        domain @c ::OIDOAuthAuthorizationErrorDomain are reflected in the auth state, other errors
+        are assumed to be transient, and ignored.
+    @discussion Typically called with the response from an incremental authorization request,
+        or if using the implicit flow. Will clear the @c #lastTokenResponse property.
+ */
+- (void)updateWithAuthorizationResponse:(nullable OIDAuthorizationResponse *)authorizationResponse
+                                  error:(nullable NSError *)error;
+
+/*! @brief Updates the authorization state based on a new token response.
+    @param tokenResponse The new token response to update the state from.
+    @param error Any error encountered when performing the authorization request. Errors in the
+        domain @c ::OIDOAuthTokenErrorDomain are reflected in the auth state, other errors
+        are assumed to be transient, and ignored.
+    @discussion Typically called with the response from an authorization code exchange, or a token
+        refresh.
+ */
+- (void)updateWithTokenResponse:(nullable OIDTokenResponse *)tokenResponse
+                          error:(nullable NSError *)error;
+
+/*! @brief Updates the authorization state based on a new registration response.
+    @param registrationResponse The new registration response to update the state with.
+    @discussion Typically called with the response from a successful client registration
+        request. Will reset the auth state.
+ */
+- (void)updateWithRegistrationResponse:(nullable OIDRegistrationResponse *)registrationResponse;
+
+/*! @brief Updates the authorization state based on an authorization error.
+    @param authorizationError The authorization error.
+    @discussion Call this method if you receive an authorization error during an API call to
+        invalidate the authentication state of this @c OIDAuthState. Don't call with errors
+        unrelated to authorization, such as transient network errors.
+        The OIDAuthStateErrorDelegate.authState:didEncounterAuthorizationError: method of
+        @c #errorDelegate will be called with the error.
+        You may optionally use the convenience method
+        OIDErrorUtilities.resourceServerAuthorizationErrorWithCode:errorResponse:underlyingError:
+        to create \NSError objects for use here.
+        The latest error received is stored in @c #authorizationError. Note: that after unarchiving
+        this object, the \NSError_userInfo property of this error will be nil.
+ */
+- (void)updateWithAuthorizationError:(NSError *)authorizationError;
+
+/*! @brief Calls the block with a valid access token (refreshing it first, if needed), or if a
+        refresh was needed and failed, with the error that caused it to fail.
+    @param action The block to execute with a fresh token. This block will be executed on the main
+        thread.
+ */
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action;
+
+/*! @brief Calls the block with a valid access token (refreshing it first, if needed), or if a
+        refresh was needed and failed, with the error that caused it to fail.
+    @param action The block to execute with a fresh token. This block will be executed on the main
+        thread.
+    @param additionalParameters Additional parameters for the token request if token is
+        refreshed.
+ */
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action
+         additionalRefreshParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Calls the block with a valid access token (refreshing it first, if needed), or if a
+        refresh was needed and failed, with the error that caused it to fail.
+    @param action The block to execute with a fresh token. This block will be executed on the main
+        thread.
+    @param additionalParameters Additional parameters for the token request if token is
+        refreshed.
+    @param dispatchQueue The dispatchQueue on which to dispatch the action block.
+ */
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action
+         additionalRefreshParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+                       dispatchQueue:(dispatch_queue_t)dispatchQueue;
+
+/*! @brief Forces a token refresh the next time @c OIDAuthState.performActionWithFreshTokens: is
+        called, even if the current tokens are considered valid.
+ */
+- (void)setNeedsTokenRefresh;
+
+/*! @brief Creates a token request suitable for refreshing an access token.
+    @return A @c OIDTokenRequest suitable for using a refresh token to obtain a new access token.
+    @discussion After performing the refresh, call @c OIDAuthState.updateWithTokenResponse:error:
+        to update the authorization state based on the response. Rather than doing the token refresh
+        yourself, you should use @c OIDAuthState.performActionWithFreshTokens:.
+    @see https://tools.ietf.org/html/rfc6749#section-1.5
+ */
+- (nullable OIDTokenRequest *)tokenRefreshRequest;
+
+/*! @brief Creates a token request suitable for refreshing an access token.
+    @param additionalParameters Additional parameters for the token request.
+    @return A @c OIDTokenRequest suitable for using a refresh token to obtain a new access token.
+    @discussion After performing the refresh, call @c OIDAuthState.updateWithTokenResponse:error:
+        to update the authorization state based on the response. Rather than doing the token refresh
+        yourself, you should use @c OIDAuthState.performActionWithFreshTokens:.
+    @see https://tools.ietf.org/html/rfc6749#section-1.5
+ */
+- (nullable OIDTokenRequest *)tokenRefreshRequestWithAdditionalParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthState.m

@@ -0,0 +1,570 @@
+/*! @file OIDAuthState.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthState.h"
+
+#import "OIDAuthStateChangeDelegate.h"
+#import "OIDAuthStateErrorDelegate.h"
+#import "OIDAuthorizationRequest.h"
+#import "OIDAuthorizationResponse.h"
+#import "OIDAuthorizationService.h"
+#import "OIDDefines.h"
+#import "OIDError.h"
+#import "OIDErrorUtilities.h"
+#import "OIDRegistrationResponse.h"
+#import "OIDTokenRequest.h"
+#import "OIDTokenResponse.h"
+#import "OIDTokenUtilities.h"
+
+/*! @brief Key used to encode the @c refreshToken property for @c NSSecureCoding.
+ */
+static NSString *const kRefreshTokenKey = @"refreshToken";
+
+/*! @brief Key used to encode the @c needsTokenRefresh property for @c NSSecureCoding.
+ */
+static NSString *const kNeedsTokenRefreshKey = @"needsTokenRefresh";
+
+/*! @brief Key used to encode the @c scope property for @c NSSecureCoding.
+ */
+static NSString *const kScopeKey = @"scope";
+
+/*! @brief Key used to encode the @c lastAuthorizationResponse property for @c NSSecureCoding.
+ */
+static NSString *const kLastAuthorizationResponseKey = @"lastAuthorizationResponse";
+
+/*! @brief Key used to encode the @c lastTokenResponse property for @c NSSecureCoding.
+ */
+static NSString *const kLastTokenResponseKey = @"lastTokenResponse";
+
+/*! @brief Key used to encode the @c lastOAuthError property for @c NSSecureCoding.
+ */
+static NSString *const kAuthorizationErrorKey = @"authorizationError";
+
+/*! @brief The exception thrown when a developer tries to create a refresh request from an
+        authorization request with no authorization code.
+ */
+static NSString *const kRefreshTokenRequestException =
+    @"Attempted to create a token refresh request from a token response with no refresh token.";
+
+/*! @brief Number of seconds the access token is refreshed before it actually expires.
+ */
+static const NSUInteger kExpiryTimeTolerance = 60;
+
+/*! @brief Object to hold OIDAuthState pending actions.
+ */
+@interface OIDAuthStatePendingAction : NSObject
+@property(nonatomic, readonly, nullable) OIDAuthStateAction action;
+@property(nonatomic, readonly, nullable) dispatch_queue_t dispatchQueue;
+@end
+@implementation OIDAuthStatePendingAction
+- (id)initWithAction:(OIDAuthStateAction)action andDispatchQueue:(dispatch_queue_t)dispatchQueue {
+  self = [super init];
+  if (self) {
+    _action = action;
+    _dispatchQueue = dispatchQueue;
+  }
+  return self;
+}
+@end
+
+@interface OIDAuthState ()
+
+/*! @brief The access token generated by the authorization server.
+    @discussion Rather than using this property directly, you should call
+        @c OIDAuthState.withFreshTokenPerformAction:.
+ */
+@property(nonatomic, readonly, nullable) NSString *accessToken;
+
+/*! @brief The approximate expiration date & time of the access token.
+    @discussion Rather than using this property directly, you should call
+        @c OIDAuthState.withFreshTokenPerformAction:.
+ */
+@property(nonatomic, readonly, nullable) NSDate *accessTokenExpirationDate;
+
+/*! @brief ID Token value associated with the authenticated session.
+    @discussion Rather than using this property directly, you should call
+        OIDAuthState.withFreshTokenPerformAction:.
+ */
+@property(nonatomic, readonly, nullable) NSString *idToken;
+
+/*! @brief Private method, called when the internal state changes.
+ */
+- (void)didChangeState;
+
+@end
+
+
+@implementation OIDAuthState {
+  /*! @brief Array of pending actions (use @c _pendingActionsSyncObject to synchronize access).
+   */
+  NSMutableArray *_pendingActions;
+
+  /*! @brief Object for synchronizing access to @c pendingActions.
+   */
+  id _pendingActionsSyncObject;
+
+  /*! @brief If YES, tokens will be refreshed on the next API call regardless of expiry.
+   */
+  BOOL _needsTokenRefresh;
+}
+
+#pragma mark - Convenience initializers
+
++ (id<OIDExternalUserAgentSession>)
+    authStateByPresentingAuthorizationRequest:(OIDAuthorizationRequest *)authorizationRequest
+                            externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                                     callback:(OIDAuthStateAuthorizationCallback)callback {
+  // presents the authorization request
+  id<OIDExternalUserAgentSession> authFlowSession = [OIDAuthorizationService
+      presentAuthorizationRequest:authorizationRequest
+                externalUserAgent:externalUserAgent
+                         callback:^(OIDAuthorizationResponse *_Nullable authorizationResponse,
+                                    NSError *_Nullable authorizationError) {
+                           // inspects response and processes further if needed (e.g. authorization
+                           // code exchange)
+                           if (authorizationResponse) {
+                             if ([authorizationRequest.responseType
+                                     isEqualToString:OIDResponseTypeCode]) {
+                               // if the request is for the code flow (NB. not hybrid), assumes the
+                               // code is intended for this client, and performs the authorization
+                               // code exchange
+                               OIDTokenRequest *tokenExchangeRequest =
+                                   [authorizationResponse tokenExchangeRequest];
+                               [OIDAuthorizationService performTokenRequest:tokenExchangeRequest
+                                              originalAuthorizationResponse:authorizationResponse
+                                   callback:^(OIDTokenResponse *_Nullable tokenResponse,
+                                                         NSError *_Nullable tokenError) {
+                                                OIDAuthState *authState;
+                                                if (tokenResponse) {
+                                                  authState = [[OIDAuthState alloc]
+                                                      initWithAuthorizationResponse:
+                                                          authorizationResponse
+                                                                      tokenResponse:tokenResponse];
+                                                }
+                                                callback(authState, tokenError);
+                               }];
+                             } else {
+                               // hybrid flow (code id_token). Two possible cases:
+                               // 1. The code is not for this client, ie. will be sent to a
+                               //    webservice that performs the id token verification and token
+                               //    exchange
+                               // 2. The code is for this client and, for security reasons, the
+                               //    application developer must verify the id_token signature and
+                               //    c_hash before calling the token endpoint
+                               OIDAuthState *authState = [[OIDAuthState alloc]
+                                   initWithAuthorizationResponse:authorizationResponse];
+                               callback(authState, authorizationError);
+                             }
+                           } else {
+                             callback(nil, authorizationError);
+                           }
+                         }];
+  return authFlowSession;
+}
+
+#pragma mark - Initializers
+
+- (nonnull instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithAuthorizationResponse:tokenResponse:))
+
+/*! @brief Creates an auth state from an authorization response.
+    @param authorizationResponse The authorization response.
+ */
+- (instancetype)initWithAuthorizationResponse:(OIDAuthorizationResponse *)authorizationResponse {
+  return [self initWithAuthorizationResponse:authorizationResponse tokenResponse:nil];
+}
+
+
+/*! @brief Designated initializer.
+    @param authorizationResponse The authorization response.
+    @discussion Creates an auth state from an authorization response and token response.
+ */
+- (instancetype)initWithAuthorizationResponse:(OIDAuthorizationResponse *)authorizationResponse
+                                         tokenResponse:(nullable OIDTokenResponse *)tokenResponse {
+  return [self initWithAuthorizationResponse:authorizationResponse
+                               tokenResponse:tokenResponse
+                        registrationResponse:nil];
+}
+
+/*! @brief Creates an auth state from an registration response.
+    @param registrationResponse The registration response.
+ */
+- (instancetype)initWithRegistrationResponse:(OIDRegistrationResponse *)registrationResponse {
+  return [self initWithAuthorizationResponse:nil
+                               tokenResponse:nil
+                        registrationResponse:registrationResponse];
+}
+
+- (instancetype)initWithAuthorizationResponse:
+    (nullable OIDAuthorizationResponse *)authorizationResponse
+           tokenResponse:(nullable OIDTokenResponse *)tokenResponse
+    registrationResponse:(nullable OIDRegistrationResponse *)registrationResponse {
+  self = [super init];
+  if (self) {
+    _pendingActionsSyncObject = [[NSObject alloc] init];
+
+    if (registrationResponse) {
+      [self updateWithRegistrationResponse:registrationResponse];
+    }
+
+    if (authorizationResponse) {
+      [self updateWithAuthorizationResponse:authorizationResponse error:nil];
+    }
+
+    if (tokenResponse) {
+      [self updateWithTokenResponse:tokenResponse error:nil];
+    }
+  }
+  return self;
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, isAuthorized: %@, refreshToken: \"%@\", "
+                                     "scope: \"%@\", accessToken: \"%@\", "
+                                     "accessTokenExpirationDate: %@, idToken: \"%@\", "
+                                     "lastAuthorizationResponse: %@, lastTokenResponse: %@, "
+                                     "lastRegistrationResponse: %@, authorizationError: %@>",
+                                    NSStringFromClass([self class]),
+                                    (void *)self,
+                                    (self.isAuthorized) ? @"YES" : @"NO",
+                                    [OIDTokenUtilities redact:_refreshToken],
+                                    _scope,
+                                    [OIDTokenUtilities redact:self.accessToken],
+                                    self.accessTokenExpirationDate,
+                                    [OIDTokenUtilities redact:self.idToken],
+                                    _lastAuthorizationResponse,
+                                    _lastTokenResponse,
+                                    _lastRegistrationResponse,
+                                    _authorizationError];
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  _lastAuthorizationResponse = [aDecoder decodeObjectOfClass:[OIDAuthorizationResponse class]
+                                                      forKey:kLastAuthorizationResponseKey];
+  _lastTokenResponse = [aDecoder decodeObjectOfClass:[OIDTokenResponse class]
+                                              forKey:kLastTokenResponseKey];
+  self = [self initWithAuthorizationResponse:_lastAuthorizationResponse
+                               tokenResponse:_lastTokenResponse];
+  if (self) {
+    _authorizationError =
+        [aDecoder decodeObjectOfClass:[NSError class] forKey:kAuthorizationErrorKey];
+    _scope = [aDecoder decodeObjectOfClass:[NSString class] forKey:kScopeKey];
+    _refreshToken = [aDecoder decodeObjectOfClass:[NSString class] forKey:kRefreshTokenKey];
+    _needsTokenRefresh = [aDecoder decodeBoolForKey:kNeedsTokenRefreshKey];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_lastAuthorizationResponse forKey:kLastAuthorizationResponseKey];
+  [aCoder encodeObject:_lastTokenResponse forKey:kLastTokenResponseKey];
+  if (_authorizationError) {
+    NSError *codingSafeAuthorizationError = [NSError errorWithDomain:_authorizationError.domain
+                                                                code:_authorizationError.code
+                                                            userInfo:nil];
+    [aCoder encodeObject:codingSafeAuthorizationError forKey:kAuthorizationErrorKey];
+  }
+  [aCoder encodeObject:_scope forKey:kScopeKey];
+  [aCoder encodeObject:_refreshToken forKey:kRefreshTokenKey];
+  [aCoder encodeBool:_needsTokenRefresh forKey:kNeedsTokenRefreshKey];
+}
+
+#pragma mark - Private convenience getters
+
+- (NSString *)accessToken {
+  if (_authorizationError) {
+    return nil;
+  }
+  return _lastTokenResponse ? _lastTokenResponse.accessToken
+                            : _lastAuthorizationResponse.accessToken;
+}
+
+- (NSString *)tokenType {
+  if (_authorizationError) {
+    return nil;
+  }
+  return _lastTokenResponse ? _lastTokenResponse.tokenType
+                            : _lastAuthorizationResponse.tokenType;
+}
+
+- (NSDate *)accessTokenExpirationDate {
+  if (_authorizationError) {
+    return nil;
+  }
+  return _lastTokenResponse ? _lastTokenResponse.accessTokenExpirationDate
+                            : _lastAuthorizationResponse.accessTokenExpirationDate;
+}
+
+- (NSString *)idToken {
+  if (_authorizationError) {
+    return nil;
+  }
+  return _lastTokenResponse ? _lastTokenResponse.idToken
+                            : _lastAuthorizationResponse.idToken;
+}
+
+#pragma mark - Getters
+
+- (BOOL)isAuthorized {
+  return !self.authorizationError && (self.accessToken || self.idToken || self.refreshToken);
+}
+
+#pragma mark - Updating the state
+
+- (void)updateWithRegistrationResponse:(OIDRegistrationResponse *)registrationResponse {
+  _lastRegistrationResponse = registrationResponse;
+  _refreshToken = nil;
+  _scope = nil;
+  _lastAuthorizationResponse = nil;
+  _lastTokenResponse = nil;
+  _authorizationError = nil;
+  [self didChangeState];
+}
+
+- (void)updateWithAuthorizationResponse:(nullable OIDAuthorizationResponse *)authorizationResponse
+                                  error:(nullable NSError *)error {
+  // If the error is an OAuth authorization error, updates the state. Other errors are ignored.
+  if (error.domain == OIDOAuthAuthorizationErrorDomain) {
+    [self updateWithAuthorizationError:error];
+    return;
+  }
+  if (!authorizationResponse) {
+    return;
+  }
+
+  _lastAuthorizationResponse = authorizationResponse;
+
+  // clears the last token response and refresh token as these now relate to an old authorization
+  // that is no longer relevant
+  _lastTokenResponse = nil;
+  _refreshToken = nil;
+  _authorizationError = nil;
+
+  // if the response's scope is nil, it means that it equals that of the request
+  // see: https://tools.ietf.org/html/rfc6749#section-5.1
+  _scope = (authorizationResponse.scope) ? authorizationResponse.scope
+                                         : authorizationResponse.request.scope;
+
+  [self didChangeState];
+}
+
+- (void)updateWithTokenResponse:(nullable OIDTokenResponse *)tokenResponse
+                          error:(nullable NSError *)error {
+  if (_authorizationError) {
+    // Calling updateWithTokenResponse while in an error state probably means the developer obtained
+    // a new token and did the exchange without also calling updateWithAuthorizationResponse.
+    // Attempts to handle gracefully, but warns the developer that this is unexpected.
+    NSLog(@"OIDAuthState:updateWithTokenResponse should not be called in an error state [%@] call"
+         "updateWithAuthorizationResponse with the result of the fresh authorization response"
+         "first",
+         _authorizationError);
+
+    _authorizationError = nil;
+  }
+
+  // If the error is an OAuth authorization error, updates the state. Other errors are ignored.
+  if (error.domain == OIDOAuthTokenErrorDomain) {
+    [self updateWithAuthorizationError:error];
+    return;
+  }
+  if (!tokenResponse) {
+    return;
+  }
+
+  _lastTokenResponse = tokenResponse;
+
+  // updates the scope and refresh token if they are present on the TokenResponse.
+  // according to the spec, these may be changed by the server, including when refreshing the
+  // access token. See: https://tools.ietf.org/html/rfc6749#section-5.1 and
+  // https://tools.ietf.org/html/rfc6749#section-6
+  if (tokenResponse.scope) {
+    _scope = tokenResponse.scope;
+  }
+  if (tokenResponse.refreshToken) {
+    _refreshToken = tokenResponse.refreshToken;
+  }
+
+  [self didChangeState];
+}
+
+- (void)updateWithAuthorizationError:(NSError *)oauthError {
+  _authorizationError = oauthError;
+
+  [self didChangeState];
+
+  [_errorDelegate authState:self didEncounterAuthorizationError:oauthError];
+}
+
+#pragma mark - OAuth Requests
+
+- (OIDTokenRequest *)tokenRefreshRequest {
+  return [self tokenRefreshRequestWithAdditionalParameters:nil];
+}
+
+- (OIDTokenRequest *)tokenRefreshRequestWithAdditionalParameters:
+    (NSDictionary<NSString *, NSString *> *)additionalParameters {
+
+  // TODO: Add unit test to confirm exception is thrown when expected
+
+  if (!_refreshToken) {
+    [OIDErrorUtilities raiseException:kRefreshTokenRequestException];
+  }
+  return [[OIDTokenRequest alloc]
+      initWithConfiguration:_lastAuthorizationResponse.request.configuration
+                  grantType:OIDGrantTypeRefreshToken
+          authorizationCode:nil
+                redirectURL:nil
+                   clientID:_lastAuthorizationResponse.request.clientID
+               clientSecret:_lastAuthorizationResponse.request.clientSecret
+                      scope:nil
+               refreshToken:_refreshToken
+               codeVerifier:nil
+       additionalParameters:additionalParameters];
+}
+
+#pragma mark - Stateful Actions
+
+- (void)didChangeState {
+  [_stateChangeDelegate didChangeState:self];
+}
+
+- (void)setNeedsTokenRefresh {
+  _needsTokenRefresh = YES;
+}
+
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action {
+  [self performActionWithFreshTokens:action additionalRefreshParameters:nil];
+}
+
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action
+         additionalRefreshParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  [self performActionWithFreshTokens:action
+         additionalRefreshParameters:additionalParameters
+                       dispatchQueue:dispatch_get_main_queue()];
+}
+
+- (void)performActionWithFreshTokens:(OIDAuthStateAction)action
+         additionalRefreshParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+                       dispatchQueue:(dispatch_queue_t)dispatchQueue {
+
+  if ([self isTokenFresh]) {
+    // access token is valid within tolerance levels, perform action
+    dispatch_async(dispatchQueue, ^{
+      action(self.accessToken, self.idToken, nil);
+    });
+    return;
+  }
+
+  if (!_refreshToken) {
+    // no refresh token available and token has expired
+    NSError *tokenRefreshError = [
+      OIDErrorUtilities errorWithCode:OIDErrorCodeTokenRefreshError
+                      underlyingError:nil
+                          description:@"Unable to refresh expired token without a refresh token."];
+    dispatch_async(dispatchQueue, ^{
+        action(nil, nil, tokenRefreshError);
+    });
+    return;
+  }
+
+  // access token is expired, first refresh the token, then perform action
+  NSAssert(_pendingActionsSyncObject, @"_pendingActionsSyncObject cannot be nil", @"");
+  OIDAuthStatePendingAction* pendingAction =
+      [[OIDAuthStatePendingAction alloc] initWithAction:action andDispatchQueue:dispatchQueue];
+  @synchronized(_pendingActionsSyncObject) {
+    // if a token is already in the process of being refreshed, adds to pending actions
+    if (_pendingActions) {
+      [_pendingActions addObject:pendingAction];
+      return;
+    }
+
+    // creates a list of pending actions, starting with this one
+    _pendingActions = [NSMutableArray arrayWithObject:pendingAction];
+  }
+
+  // refresh the tokens
+  OIDTokenRequest *tokenRefreshRequest =
+      [self tokenRefreshRequestWithAdditionalParameters:additionalParameters];
+  [OIDAuthorizationService performTokenRequest:tokenRefreshRequest
+                 originalAuthorizationResponse:_lastAuthorizationResponse
+                                      callback:^(OIDTokenResponse *_Nullable response,
+                                                 NSError *_Nullable error) {
+    // update OIDAuthState based on response
+    if (response) {
+      self->_needsTokenRefresh = NO;
+      [self updateWithTokenResponse:response error:nil];
+    } else {
+      if (error.domain == OIDOAuthTokenErrorDomain) {
+        self->_needsTokenRefresh = NO;
+        [self updateWithAuthorizationError:error];
+      } else {
+        if ([self->_errorDelegate respondsToSelector:
+            @selector(authState:didEncounterTransientError:)]) {
+          [self->_errorDelegate authState:self didEncounterTransientError:error];
+        }
+      }
+    }
+
+    // nil the pending queue and process everything that was queued up
+    NSArray *actionsToProcess;
+    @synchronized(self->_pendingActionsSyncObject) {
+      actionsToProcess = self->_pendingActions;
+      self->_pendingActions = nil;
+    }
+    for (OIDAuthStatePendingAction* actionToProcess in actionsToProcess) {
+      dispatch_async(actionToProcess.dispatchQueue, ^{
+        actionToProcess.action(self.accessToken, self.idToken, error);
+      });
+    }
+  }];
+}
+
+#pragma mark -
+
+/*! @fn isTokenFresh
+    @brief Determines whether a token refresh request must be made to refresh the tokens.
+ */
+- (BOOL)isTokenFresh {
+  if (_needsTokenRefresh) {
+    // forced refresh
+    return NO;
+  }
+
+  if (!self.accessTokenExpirationDate) {
+    // if there is no expiration time but we have an access token, it is assumed to never expire
+    return !!self.accessToken;
+  }
+
+  // has the token expired?
+  BOOL tokenFresh = [self.accessTokenExpirationDate timeIntervalSinceNow] > kExpiryTimeTolerance;
+  return tokenFresh;
+}
+
+@end
+
+

Pods/AppAuth/Source/AppAuthCore/OIDAuthStateChangeDelegate.h

@@ -0,0 +1,39 @@
+/*! @file OIDAuthStateChangeDelegate.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDAuthState;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @protocol OIDAuthStateChangeDelegate
+    @brief Delegate of the OIDAuthState used to monitor various changes in state.
+ */
+@protocol OIDAuthStateChangeDelegate <NSObject>
+
+/*! @brief Called when the authorization state changes and any backing storage needs to be updated.
+    @param state The @c OIDAuthState that changed.
+    @discussion If you are storing the authorization state, you should update the storage when the
+        state changes.
+ */
+- (void)didChangeState:(OIDAuthState *)state;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthStateErrorDelegate.h

@@ -0,0 +1,62 @@
+/*! @file OIDAuthStateErrorDelegate.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDAuthState;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @protocol OIDAuthStateErrorDelegate
+    @brief Delegate of the OIDAuthState used to monitor errors.
+ */
+@protocol OIDAuthStateErrorDelegate <NSObject>
+
+/*! @brief Called when an authentication occurs, which indicates the auth session is invalid.
+    @param state The @c OIDAuthState on which the error occurred.
+    @param error The authorization error.
+    @discussion This is a hard error (not a transient network issue) that indicates a problem with
+        the authorization. You should stop using the @c OIDAuthState when such an error is
+        encountered. If the \NSError_code is @c ::OIDErrorCodeOAuthInvalidGrant then
+        the session may be recoverable with user interaction (i.e. re-authentication). In all cases
+        you should consider the user unauthorized, and remove locally cached resources that require
+        that authorization.  @c OIDAuthState will call this method automatically if it encounters
+        an OAuth error (that is, an HTTP 400 response with a valid OAuth error response) during
+        authorization or token refresh (such as performed automatically when using
+        @c OIDAuthState.performActionWithFreshTokens:). You can signal authorization errors with
+        @c OIDAuthState.updateWithAuthorizationError:.
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+- (void)authState:(OIDAuthState *)state didEncounterAuthorizationError:(NSError *)error;
+
+@optional
+
+/*! @brief Called when a network or other transient error occurs.
+    @param state The @c OIDAuthState on which the error occurred.
+    @param error The transient error.
+    @discussion This is a soft error, typically network related. The @c OIDAuthState is likely
+        still valid, and should not be discarded. Retry the request using an incremental backoff
+        strategy. This is only called when using the @c OIDAuthState convenience methods such as
+        @c OIDAuthState.performActionWithFreshTokens:. If you are refreshing the tokens yourself
+        outside of @c OIDAuthState class, it will never be called.
+ */
+- (void)authState:(OIDAuthState *)state didEncounterTransientError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationRequest.h

@@ -0,0 +1,250 @@
+/*! @file OIDAuthorizationRequest.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+// These files only declare string constants useful for constructing a @c OIDAuthorizationRequest,
+// so they are imported here for convenience.
+#import "OIDExternalUserAgentRequest.h"
+#import "OIDResponseTypes.h"
+#import "OIDScopes.h"
+
+@class OIDServiceConfiguration;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief The @c code_challenge_method  value for the S256 code challenge.
+    @see https://tools.ietf.org/html/rfc7636#section-4.3
+ */
+extern NSString *const OIDOAuthorizationRequestCodeChallengeMethodS256;
+
+
+/*! @brief Represents an authorization request.
+    @see https://tools.ietf.org/html/rfc6749#section-4
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+@interface OIDAuthorizationRequest :
+    NSObject<NSCopying, NSSecureCoding, OIDExternalUserAgentRequest>
+
+/*! @brief The service's configuration.
+    @remarks This configuration specifies how to connect to a particular OAuth provider.
+        Configurations may be created manually, or via an OpenID Connect Discovery Document.
+ */
+@property(nonatomic, readonly) OIDServiceConfiguration *configuration;
+
+/*! @brief The expected response type.
+    @remarks response_type
+    @discussion Generally 'code' if pure OAuth, otherwise a space-delimited list of of response
+        types including 'code', 'token', and 'id_token' for OpenID Connect.
+    @see https://tools.ietf.org/html/rfc6749#section-3.1.1
+    @see http://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3
+ */
+@property(nonatomic, readonly) NSString *responseType;
+
+/*! @brief The client identifier.
+    @remarks client_id
+    @see https://tools.ietf.org/html/rfc6749#section-2.2
+ */
+@property(nonatomic, readonly) NSString *clientID;
+
+/*! @brief The client secret.
+    @remarks client_secret
+    @discussion The client secret is used to prove that identity of the client when exchaning an
+        authorization code for an access token.
+        The client secret is not passed in the authorizationRequestURL. It is only used when
+        exchanging the authorization code for an access token.
+    @see https://tools.ietf.org/html/rfc6749#section-2.3.1
+ */
+@property(nonatomic, readonly, nullable) NSString *clientSecret;
+
+/*! @brief The value of the scope parameter is expressed as a list of space-delimited,
+        case-sensitive strings.
+    @remarks scope
+    @see https://tools.ietf.org/html/rfc6749#section-3.3
+ */
+@property(nonatomic, readonly, nullable) NSString *scope;
+
+/*! @brief The client's redirect URI.
+    @remarks redirect_uri
+    @see https://tools.ietf.org/html/rfc6749#section-3.1.2
+ */
+@property(nonatomic, readonly, nullable) NSURL *redirectURL;
+
+/*! @brief An opaque value used by the client to maintain state between the request and callback.
+    @remarks state
+    @discussion If this value is not explicitly set, this library will automatically add state and
+        perform appropriate validation of the state in the authorization response. It is recommended
+        that the default implementation of this parameter be used wherever possible. Typically used
+        to prevent CSRF attacks, as recommended in RFC6819 Section 5.3.5.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+    @see https://tools.ietf.org/html/rfc6819#section-5.3.5
+ */
+@property(nonatomic, readonly, nullable) NSString *state;
+
+/*! @brief String value used to associate a Client session with an ID Token, and to mitigate replay
+        attacks. The value is passed through unmodified from the Authentication Request to the ID
+        Token. Sufficient entropy MUST be present in the nonce values used to prevent attackers from
+        guessing values.
+    @remarks nonce
+    @discussion If this value is not explicitly set, this library will automatically add nonce and
+        perform appropriate validation of the nonce in the ID Token.
+    @see https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest
+ */
+@property(nonatomic, readonly, nullable) NSString *nonce;
+
+/*! @brief The PKCE code verifier.
+    @remarks code_verifier
+    @discussion The code verifier itself is not included in the authorization request that is sent
+        on the wire, but needs to be in the token exchange request.
+        @c OIDAuthorizationResponse.tokenExchangeRequest will create a @c OIDTokenRequest that
+        includes this parameter automatically.
+    @see https://tools.ietf.org/html/rfc7636#section-4.1
+ */
+@property(nonatomic, readonly, nullable) NSString *codeVerifier;
+
+/*! @brief The PKCE code challenge, derived from #codeVerifier.
+    @remarks code_challenge
+    @see https://tools.ietf.org/html/rfc7636#section-4.2
+ */
+@property(nonatomic, readonly, nullable) NSString *codeChallenge;
+
+/*! @brief The method used to compute the @c #codeChallenge
+    @remarks code_challenge_method
+    @see https://tools.ietf.org/html/rfc7636#section-4.3
+ */
+@property(nonatomic, readonly, nullable) NSString *codeChallengeMethod;
+
+/*! @brief The client's additional authorization parameters.
+    @see https://tools.ietf.org/html/rfc6749#section-3.1
+ */
+@property(nonatomic, readonly, nullable) NSDictionary<NSString *, NSString *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use
+        @c initWithConfiguration:clientId:scopes:redirectURL:responseType:additionalParameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Creates an authorization request with opinionated defaults (a secure @c state, and
+        PKCE with S256 as the @c code_challenge_method).
+    @param configuration The service's configuration.
+    @param clientID The client identifier.
+    @param scopes An array of scopes to combine into a single scope string per the OAuth2 spec.
+    @param redirectURL The client's redirect URI.
+    @param responseType The expected response type.
+    @param additionalParameters The client's additional authorization parameters.
+    @remarks This convenience initializer generates a state parameter and PKCE challenges
+        automatically.
+ */
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+                 clientId:(NSString *)clientID
+                   scopes:(nullable NSArray<NSString *> *)scopes
+              redirectURL:(NSURL *)redirectURL
+             responseType:(NSString *)responseType
+     additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Creates an authorization request with opinionated defaults (a secure @c state, @c nonce,
+        and PKCE with S256 as the @c code_challenge_method).
+    @param configuration The service's configuration.
+    @param clientID The client identifier.
+    @param clientSecret The client secret.
+    @param scopes An array of scopes to combine into a single scope string per the OAuth2 spec.
+    @param redirectURL The client's redirect URI.
+    @param responseType The expected response type.
+    @param additionalParameters The client's additional authorization parameters.
+    @remarks This convenience initializer generates a state parameter and PKCE challenges
+        automatically.
+ */
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+                 clientId:(NSString *)clientID
+             clientSecret:(nullable NSString *)clientSecret
+                   scopes:(nullable NSArray<NSString *> *)scopes
+              redirectURL:(NSURL *)redirectURL
+             responseType:(NSString *)responseType
+     additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Designated initializer.
+    @param configuration The service's configuration.
+    @param clientID The client identifier.
+    @param scope A scope string per the OAuth2 spec (a space-delimited set of scopes).
+    @param redirectURL The client's redirect URI.
+    @param responseType The expected response type.
+    @param state An opaque value used by the client to maintain state between the request and
+        callback.
+    @param nonce String value used to associate a Client session with an ID Token. Can be set to nil
+        if not using OpenID Connect, although pure OAuth servers should ignore params they don't
+        understand anyway.
+    @param codeVerifier The PKCE code verifier. See @c OIDAuthorizationRequest.generateCodeVerifier.
+    @param codeChallenge The PKCE code challenge, calculated from the code verifier such as with
+        @c OIDAuthorizationRequest.codeChallengeS256ForVerifier:.
+    @param codeChallengeMethod The PKCE code challenge method.
+        ::OIDOAuthorizationRequestCodeChallengeMethodS256 when
+        @c OIDAuthorizationRequest.codeChallengeS256ForVerifier: is used to create the code
+        challenge.
+    @param additionalParameters The client's additional authorization parameters.
+ */
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+                 clientId:(NSString *)clientID
+             clientSecret:(nullable NSString *)clientSecret
+                    scope:(nullable NSString *)scope
+              redirectURL:(nullable NSURL *)redirectURL
+             responseType:(NSString *)responseType
+                    state:(nullable NSString *)state
+                    nonce:(nullable NSString *)nonce
+             codeVerifier:(nullable NSString *)codeVerifier
+            codeChallenge:(nullable NSString *)codeChallenge
+      codeChallengeMethod:(nullable NSString *)codeChallengeMethod
+     additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Constructs the request URI by adding the request parameters to the query component of the
+        authorization endpoint URI using the "application/x-www-form-urlencoded" format.
+    @return A URL representing the authorization request.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+- (NSURL *)authorizationRequestURL;
+
+/*! @brief Generates an OAuth state param using a random source.
+    @return The generated state.
+    @see https://tools.ietf.org/html/rfc6819#section-5.3.5
+ */
++ (nullable NSString *)generateState;
+
+/*! @brief Constructs a PKCE-compliant code verifier.
+    @return The generated code verifier.
+    @see https://tools.ietf.org/html/rfc7636#section-4.1
+ */
++ (nullable NSString *)generateCodeVerifier;
+
+/*! @brief Creates a PKCE S256 codeChallenge from the codeVerifier.
+    @param codeVerifier The code verifier from which the code challenge will be derived.
+    @return The generated code challenge.
+    @details Generate a secure code verifier to pass into this method with
+        @c OIDAuthorizationRequest.generateCodeVerifier. The matching @c #codeChallengeMethod for
+        @c #codeChallenge%s created by this method is
+        ::OIDOAuthorizationRequestCodeChallengeMethodS256.
+    @see https://tools.ietf.org/html/rfc7636#section-4.1
+ */
++ (nullable NSString *)codeChallengeS256ForVerifier:(nullable NSString *)codeVerifier;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationRequest.m

@@ -0,0 +1,351 @@
+/*! @file OIDAuthorizationRequest.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthorizationRequest.h"
+
+#import "OIDDefines.h"
+#import "OIDScopeUtilities.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDTokenUtilities.h"
+#import "OIDURLQueryComponent.h"
+
+/*! @brief The key for the @c configuration property for @c NSSecureCoding
+ */
+static NSString *const kConfigurationKey = @"configuration";
+
+/*! @brief Key used to encode the @c responseType property for @c NSSecureCoding, and on the URL
+        request.
+ */
+static NSString *const kResponseTypeKey = @"response_type";
+
+/*! @brief Key used to encode the @c clientID property for @c NSSecureCoding, and on the URL
+        request.
+ */
+static NSString *const kClientIDKey = @"client_id";
+
+/*! @brief Key used to encode the @c clientSecret property for @c NSSecureCoding.
+ */
+static NSString *const kClientSecretKey = @"client_secret";
+
+/*! @brief Key used to encode the @c scope property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kScopeKey = @"scope";
+
+/*! @brief Key used to encode the @c redirectURL property for @c NSSecureCoding, and on the URL
+        request.
+ */
+static NSString *const kRedirectURLKey = @"redirect_uri";
+
+/*! @brief Key used to encode the @c state property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kStateKey = @"state";
+
+/*! @brief Key used to encode the @c nonce property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kNonceKey = @"nonce";
+
+/*! @brief Key used to encode the @c codeVerifier property for @c NSSecureCoding.
+ */
+static NSString *const kCodeVerifierKey = @"code_verifier";
+
+/*! @brief Key used to send the @c codeChallenge on the URL request.
+ */
+static NSString *const kCodeChallengeKey = @"code_challenge";
+
+/*! @brief Key used to send the @c codeChallengeMethod on the URL request.
+ */
+static NSString *const kCodeChallengeMethodKey = @"code_challenge_method";
+
+/*! @brief Key used to encode the @c additionalParameters property for
+        @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+/*! @brief Number of random bytes generated for the @ state.
+ */
+static NSUInteger const kStateSizeBytes = 32;
+
+/*! @brief Number of random bytes generated for the @ codeVerifier.
+ */
+static NSUInteger const kCodeVerifierBytes = 32;
+
+/*! @brief Assertion text for unsupported response types.
+ */
+static NSString *const OIDOAuthUnsupportedResponseTypeMessage =
+    @"The response_type \"%@\" isn't supported. AppAuth only supports the \"code\" or \"code id_token\" response_type.";
+
+/*! @brief Code challenge request method.
+ */
+NSString *const OIDOAuthorizationRequestCodeChallengeMethodS256 = @"S256";
+
+@implementation OIDAuthorizationRequest
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(
+        @selector(initWithConfiguration:
+                               clientId:
+                                 scopes:
+                            redirectURL:
+                           responseType:
+                   additionalParameters:)
+    )
+
+/*! @brief Check if the response type is one AppAuth supports
+    @remarks AppAuth only supports the `code` and `code id_token` response types.
+    @see https://github.com/openid/AppAuth-iOS/issues/98
+    @see https://github.com/openid/AppAuth-iOS/issues/292
+ */
++ (BOOL)isSupportedResponseType:(NSString *)responseType
+{
+  NSString *codeIdToken = [@[OIDResponseTypeCode, OIDResponseTypeIDToken]
+                           componentsJoinedByString:@" "];
+  NSString *idTokenCode = [@[OIDResponseTypeIDToken, OIDResponseTypeCode]
+                           componentsJoinedByString:@" "];
+
+  return [responseType isEqualToString:OIDResponseTypeCode]
+         || [responseType isEqualToString:codeIdToken]
+         || [responseType isEqualToString:idTokenCode];
+}
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+                clientId:(NSString *)clientID
+            clientSecret:(nullable NSString *)clientSecret
+                   scope:(nullable NSString *)scope
+             redirectURL:(NSURL *)redirectURL
+            responseType:(NSString *)responseType
+                   state:(nullable NSString *)state
+                   nonce:(nullable NSString *)nonce
+            codeVerifier:(nullable NSString *)codeVerifier
+           codeChallenge:(nullable NSString *)codeChallenge
+     codeChallengeMethod:(nullable NSString *)codeChallengeMethod
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+{
+  self = [super init];
+  if (self) {
+    _configuration = [configuration copy];
+    _clientID = [clientID copy];
+    _clientSecret = [clientSecret copy];
+    _scope = [scope copy];
+    _redirectURL = [redirectURL copy];
+    _responseType = [responseType copy];
+    if (![[self class] isSupportedResponseType:_responseType]) {
+      NSAssert(NO, OIDOAuthUnsupportedResponseTypeMessage, _responseType);
+      return nil;
+    }
+    _state = [state copy];
+    _nonce = [nonce copy];
+    _codeVerifier = [codeVerifier copy];
+    _codeChallenge = [codeChallenge copy];
+    _codeChallengeMethod = [codeChallengeMethod copy];
+
+    _additionalParameters =
+        [[NSDictionary alloc] initWithDictionary:additionalParameters copyItems:YES];
+  }
+  return self;
+}
+
+- (instancetype)
+   initWithConfiguration:(OIDServiceConfiguration *)configuration
+                clientId:(NSString *)clientID
+            clientSecret:(NSString *)clientSecret
+                  scopes:(nullable NSArray<NSString *> *)scopes
+             redirectURL:(NSURL *)redirectURL
+            responseType:(NSString *)responseType
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+
+  // generates PKCE code verifier and challenge
+  NSString *codeVerifier = [[self class] generateCodeVerifier];
+  NSString *codeChallenge = [[self class] codeChallengeS256ForVerifier:codeVerifier];
+
+  return [self initWithConfiguration:configuration
+                            clientId:clientID
+                        clientSecret:clientSecret
+                               scope:[OIDScopeUtilities scopesWithArray:scopes]
+                         redirectURL:redirectURL
+                        responseType:responseType
+                               state:[[self class] generateState]
+                               nonce:[[self class] generateState]
+                        codeVerifier:codeVerifier
+                       codeChallenge:codeChallenge
+                 codeChallengeMethod:OIDOAuthorizationRequestCodeChallengeMethodS256
+                additionalParameters:additionalParameters];
+}
+
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+                 clientId:(NSString *)clientID
+                   scopes:(nullable NSArray<NSString *> *)scopes
+              redirectURL:(NSURL *)redirectURL
+             responseType:(NSString *)responseType
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  return [self initWithConfiguration:configuration
+                            clientId:clientID
+                        clientSecret:nil
+                              scopes:scopes
+                         redirectURL:redirectURL
+                        responseType:responseType
+                additionalParameters:additionalParameters];
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDServiceConfiguration *configuration =
+      [aDecoder decodeObjectOfClass:[OIDServiceConfiguration class]
+                             forKey:kConfigurationKey];
+  NSString *responseType = [aDecoder decodeObjectOfClass:[NSString class] forKey:kResponseTypeKey];
+  NSString *clientID = [aDecoder decodeObjectOfClass:[NSString class] forKey:kClientIDKey];
+  NSString *clientSecret = [aDecoder decodeObjectOfClass:[NSString class] forKey:kClientSecretKey];
+  NSString *scope = [aDecoder decodeObjectOfClass:[NSString class] forKey:kScopeKey];
+  NSURL *redirectURL = [aDecoder decodeObjectOfClass:[NSURL class] forKey:kRedirectURLKey];
+  NSString *state = [aDecoder decodeObjectOfClass:[NSString class] forKey:kStateKey];
+  NSString *nonce = [aDecoder decodeObjectOfClass:[NSString class] forKey:kNonceKey];
+  NSString *codeVerifier = [aDecoder decodeObjectOfClass:[NSString class] forKey:kCodeVerifierKey];
+  NSString *codeChallenge =
+      [aDecoder decodeObjectOfClass:[NSString class] forKey:kCodeChallengeKey];
+  NSString *codeChallengeMethod =
+      [aDecoder decodeObjectOfClass:[NSString class] forKey:kCodeChallengeMethodKey];
+  NSSet *additionalParameterCodingClasses = [NSSet setWithArray:@[
+    [NSDictionary class],
+    [NSString class]
+  ]];
+  NSDictionary *additionalParameters =
+      [aDecoder decodeObjectOfClasses:additionalParameterCodingClasses
+                               forKey:kAdditionalParametersKey];
+
+  self = [self initWithConfiguration:configuration
+                            clientId:clientID
+                        clientSecret:clientSecret
+                               scope:scope
+                         redirectURL:redirectURL
+                        responseType:responseType
+                               state:state
+                               nonce:nonce
+                        codeVerifier:codeVerifier
+                       codeChallenge:codeChallenge
+                 codeChallengeMethod:codeChallengeMethod
+                additionalParameters:additionalParameters];
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_configuration forKey:kConfigurationKey];
+  [aCoder encodeObject:_responseType forKey:kResponseTypeKey];
+  [aCoder encodeObject:_clientID forKey:kClientIDKey];
+  [aCoder encodeObject:_clientSecret forKey:kClientSecretKey];
+  [aCoder encodeObject:_scope forKey:kScopeKey];
+  [aCoder encodeObject:_redirectURL forKey:kRedirectURLKey];
+  [aCoder encodeObject:_state forKey:kStateKey];
+  [aCoder encodeObject:_nonce forKey:kNonceKey];
+  [aCoder encodeObject:_codeVerifier forKey:kCodeVerifierKey];
+  [aCoder encodeObject:_codeChallenge forKey:kCodeChallengeKey];
+  [aCoder encodeObject:_codeChallengeMethod forKey:kCodeChallengeMethodKey];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, request: %@>",
+                                    NSStringFromClass([self class]),
+                                    (void *)self,
+                                    self.authorizationRequestURL];
+}
+
+#pragma mark - State and PKCE verifier/challenge generation Methods
+
++ (nullable NSString *)generateCodeVerifier {
+  return [OIDTokenUtilities randomURLSafeStringWithSize:kCodeVerifierBytes];
+}
+
++ (nullable NSString *)generateState {
+  return [OIDTokenUtilities randomURLSafeStringWithSize:kStateSizeBytes];
+}
+
++ (nullable NSString *)codeChallengeS256ForVerifier:(NSString *)codeVerifier {
+  if (!codeVerifier) {
+    return nil;
+  }
+  // generates the code_challenge per spec https://tools.ietf.org/html/rfc7636#section-4.2
+  // code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier)))
+  // NB. the ASCII conversion on the code_verifier entropy was done at time of generation.
+  NSData *sha256Verifier = [OIDTokenUtilities sha256:codeVerifier];
+  return [OIDTokenUtilities encodeBase64urlNoPadding:sha256Verifier];
+}
+
+#pragma mark -
+
+- (NSURL *)authorizationRequestURL {
+  OIDURLQueryComponent *query = [[OIDURLQueryComponent alloc] init];
+
+  // Required parameters.
+  [query addParameter:kResponseTypeKey value:_responseType];
+  [query addParameter:kClientIDKey value:_clientID];
+
+  // Add any additional parameters the client has specified.
+  [query addParameters:_additionalParameters];
+
+  // Add optional parameters, as applicable.
+  if (_redirectURL) {
+    [query addParameter:kRedirectURLKey value:_redirectURL.absoluteString];
+  }
+  if (_scope) {
+    [query addParameter:kScopeKey value:_scope];
+  }
+  if (_state) {
+    [query addParameter:kStateKey value:_state];
+  }
+  if (_nonce) {
+    [query addParameter:kNonceKey value:_nonce];
+  }
+  if (_codeChallenge) {
+    [query addParameter:kCodeChallengeKey value:_codeChallenge];
+  }
+  if (_codeChallengeMethod) {
+    [query addParameter:kCodeChallengeMethodKey value:_codeChallengeMethod];
+  }
+
+  // Construct the URL:
+  return [query URLByReplacingQueryInURL:_configuration.authorizationEndpoint];
+}
+
+#pragma mark - OIDExternalUserAgentRequest
+
+- (NSURL *)externalUserAgentRequestURL {
+  return [self authorizationRequestURL];
+}
+
+- (NSString *)redirectScheme {
+  return [[self redirectURL] scheme];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationResponse.h

@@ -0,0 +1,128 @@
+/*! @file OIDAuthorizationResponse.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDAuthorizationRequest;
+@class OIDTokenRequest;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents the response to an authorization request.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
+ */
+@interface OIDAuthorizationResponse : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The request which was serviced.
+ */
+@property(nonatomic, readonly) OIDAuthorizationRequest *request;
+
+/*! @brief The authorization code generated by the authorization server.
+    @discussion Set when the response_type requested includes 'code'.
+    @remarks code
+ */
+@property(nonatomic, readonly, nullable) NSString *authorizationCode;
+
+/*! @brief REQUIRED if the "state" parameter was present in the client authorization request. The
+        exact value received from the client.
+    @remarks state
+ */
+@property(nonatomic, readonly, nullable) NSString *state;
+
+/*! @brief The access token generated by the authorization server.
+    @discussion Set when the response_type requested includes 'token'.
+    @remarks access_token
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
+ */
+@property(nonatomic, readonly, nullable) NSString *accessToken;
+
+/*! @brief The approximate expiration date & time of the access token.
+    @discussion Set when the response_type requested includes 'token'.
+    @remarks expires_in
+    @seealso OIDAuthorizationResponse.accessToken
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
+ */
+@property(nonatomic, readonly, nullable) NSDate *accessTokenExpirationDate;
+
+/*! @brief Typically "Bearer" when present. Otherwise, another token_type value that the Client has
+        negotiated with the Authorization Server.
+    @discussion Set when the response_type requested includes 'token'.
+    @remarks token_type
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
+ */
+@property(nonatomic, readonly, nullable) NSString *tokenType;
+
+/*! @brief ID Token value associated with the authenticated session.
+    @discussion Set when the response_type requested includes 'id_token'.
+    @remarks id_token
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
+ */
+@property(nonatomic, readonly, nullable) NSString *idToken;
+
+/*! @brief The scope of the access token. OPTIONAL, if identical to the scopes requested, otherwise,
+        REQUIRED.
+    @remarks scope
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *scope;
+
+/*! @brief Additional parameters returned from the authorization server.
+ */
+@property(nonatomic, readonly, nullable)
+    NSDictionary<NSString *, NSObject<NSCopying> *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use initWithRequest:parameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Designated initializer.
+    @param request The serviced request.
+    @param parameters The decoded parameters returned from the Authorization Server.
+    @remarks Known parameters are extracted from the @c parameters parameter and the normative
+        properties are populated. Non-normative parameters are placed in the
+        @c #additionalParameters dictionary.
+ */
+- (instancetype)initWithRequest:(OIDAuthorizationRequest *)request
+    parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Creates a token request suitable for exchanging an authorization code for an access
+        token.
+    @return A @c OIDTokenRequest suitable for exchanging an authorization code for an access
+        token.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+- (nullable OIDTokenRequest *)tokenExchangeRequest;
+
+/*! @brief Creates a token request suitable for exchanging an authorization code for an access
+        token.
+    @param additionalParameters Additional parameters for the token request.
+    @return A @c OIDTokenRequest suitable for exchanging an authorization code for an access
+        token.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+- (nullable OIDTokenRequest *)tokenExchangeRequestWithAdditionalParameters:
+    (nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationResponse.m

@@ -0,0 +1,210 @@
+/*! @file OIDAuthorizationResponse.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthorizationResponse.h"
+
+#import "OIDAuthorizationRequest.h"
+#import "OIDDefines.h"
+#import "OIDError.h"
+#import "OIDFieldMapping.h"
+#import "OIDTokenRequest.h"
+#import "OIDTokenUtilities.h"
+
+/*! @brief The key for the @c authorizationCode property in the incoming parameters and for
+        @c NSSecureCoding.
+ */
+static NSString *const kAuthorizationCodeKey = @"code";
+
+/*! @brief The key for the @c state property in the incoming parameters and for @c NSSecureCoding.
+ */
+static NSString *const kStateKey = @"state";
+
+/*! @brief The key for the @c accessToken property in the incoming parameters and for
+        @c NSSecureCoding.
+ */
+static NSString *const kAccessTokenKey = @"access_token";
+
+/*! @brief The key for the @c accessTokenExpirationDate property in the incoming parameters and for
+        @c NSSecureCoding.
+ */
+static NSString *const kExpiresInKey = @"expires_in";
+
+/*! @brief The key for the @c tokenType property in the incoming parameters and for
+        @c NSSecureCoding.
+ */
+static NSString *const kTokenTypeKey = @"token_type";
+
+/*! @brief The key for the @c idToken property in the incoming parameters and for @c NSSecureCoding.
+ */
+static NSString *const kIDTokenKey = @"id_token";
+
+/*! @brief The key for the @c scope property in the incoming parameters and for @c NSSecureCoding.
+ */
+static NSString *const kScopeKey = @"scope";
+
+/*! @brief Key used to encode the @c additionalParameters property for @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+/*! @brief Key used to encode the @c request property for @c NSSecureCoding
+ */
+static NSString *const kRequestKey = @"request";
+
+/*! @brief The exception thrown when a developer tries to create a token exchange request from an
+        authorization request with no authorization code.
+ */
+static NSString *const kTokenExchangeRequestException =
+    @"Attempted to create a token exchange request from an authorization response with no "
+    "authorization code.";
+
+@implementation OIDAuthorizationResponse
+
+/*! @brief Returns a mapping of incoming parameters to instance variables.
+    @return A mapping of incoming parameters to instance variables.
+ */
++ (NSDictionary<NSString *, OIDFieldMapping *> *)fieldMap {
+  static NSMutableDictionary<NSString *, OIDFieldMapping *> *fieldMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    fieldMap = [NSMutableDictionary dictionary];
+    fieldMap[kStateKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_state" type:[NSString class]];
+    fieldMap[kAuthorizationCodeKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_authorizationCode" type:[NSString class]];
+    fieldMap[kAccessTokenKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_accessToken" type:[NSString class]];
+    fieldMap[kExpiresInKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_accessTokenExpirationDate"
+                                         type:[NSDate class]
+                                   conversion:^id _Nullable(NSObject *_Nullable value) {
+          if (![value isKindOfClass:[NSNumber class]]) {
+            return value;
+          }
+          NSNumber *valueAsNumber = (NSNumber *)value;
+          return [NSDate dateWithTimeIntervalSinceNow:[valueAsNumber longLongValue]];
+        }];
+    fieldMap[kTokenTypeKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_tokenType" type:[NSString class]];
+    fieldMap[kIDTokenKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_idToken" type:[NSString class]];
+    fieldMap[kScopeKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_scope" type:[NSString class]];
+  });
+  return fieldMap;
+}
+
+#pragma mark - Initializers
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithRequest:parameters:))
+
+- (instancetype)initWithRequest:(OIDAuthorizationRequest *)request
+    parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters {
+  self = [super init];
+  if (self) {
+    _request = [request copy];
+    NSDictionary<NSString *, NSObject<NSCopying> *> *additionalParameters =
+        [OIDFieldMapping remainingParametersWithMap:[[self class] fieldMap]
+                                         parameters:parameters
+                                           instance:self];
+    _additionalParameters = additionalParameters;
+  }
+  return self;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDAuthorizationRequest *request =
+      [aDecoder decodeObjectOfClass:[OIDAuthorizationRequest class] forKey:kRequestKey];
+  self = [self initWithRequest:request parameters:@{ }];
+  if (self) {
+    [OIDFieldMapping decodeWithCoder:aDecoder map:[[self class] fieldMap] instance:self];
+    _additionalParameters = [aDecoder decodeObjectOfClasses:[OIDFieldMapping JSONTypes]
+                                                     forKey:kAdditionalParametersKey];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_request forKey:kRequestKey];
+  [OIDFieldMapping encodeWithCoder:aCoder map:[[self class] fieldMap] instance:self];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, authorizationCode: %@, state: \"%@\", accessToken: "
+                                     "\"%@\", accessTokenExpirationDate: %@, tokenType: %@, "
+                                     "idToken: \"%@\", scope: \"%@\", additionalParameters: %@, "
+                                     "request: %@>",
+                                    NSStringFromClass([self class]),
+                                    (void *)self,
+                                    _authorizationCode,
+                                    _state,
+                                    [OIDTokenUtilities redact:_accessToken],
+                                    _accessTokenExpirationDate,
+                                    _tokenType,
+                                    [OIDTokenUtilities redact:_idToken],
+                                    _scope,
+                                    _additionalParameters,
+                                    _request];
+}
+
+#pragma mark -
+
+- (OIDTokenRequest *)tokenExchangeRequest {
+  return [self tokenExchangeRequestWithAdditionalParameters:nil];
+}
+
+- (OIDTokenRequest *)tokenExchangeRequestWithAdditionalParameters:
+    (NSDictionary<NSString *, NSString *> *)additionalParameters {
+  // TODO: add a unit test to confirm exception is thrown when expected and the request is created
+  //       with the correct parameters.
+  if (!_authorizationCode) {
+    [NSException raise:kTokenExchangeRequestException
+                format:kTokenExchangeRequestException];
+  }
+  return [[OIDTokenRequest alloc] initWithConfiguration:_request.configuration
+                                              grantType:OIDGrantTypeAuthorizationCode
+                                      authorizationCode:_authorizationCode
+                                            redirectURL:_request.redirectURL
+                                               clientID:_request.clientID
+                                           clientSecret:_request.clientSecret
+                                                  scope:nil
+                                           refreshToken:nil
+                                           codeVerifier:_request.codeVerifier
+                                   additionalParameters:additionalParameters];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationService.h

@@ -0,0 +1,170 @@
+/*! @file OIDAuthorizationService.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDAuthorization;
+@class OIDAuthorizationRequest;
+@class OIDAuthorizationResponse;
+@class OIDEndSessionRequest;
+@class OIDEndSessionResponse;
+@class OIDRegistrationRequest;
+@class OIDRegistrationResponse;
+@class OIDServiceConfiguration;
+@class OIDTokenRequest;
+@class OIDTokenResponse;
+@protocol OIDExternalUserAgent;
+@protocol OIDExternalUserAgentSession;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents the type of block used as a callback for creating a service configuration from
+        a remote OpenID Connect Discovery document.
+    @param configuration The service configuration, if available.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDDiscoveryCallback)(OIDServiceConfiguration *_Nullable configuration,
+                                     NSError *_Nullable error);
+
+/*! @brief Represents the type of block used as a callback for various methods of
+        @c OIDAuthorizationService.
+    @param authorizationResponse The authorization response, if available.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDAuthorizationCallback)(OIDAuthorizationResponse *_Nullable authorizationResponse,
+                                         NSError *_Nullable error);
+
+/*! @brief Block used as a callback for the end-session request of @c OIDAuthorizationService.
+    @param endSessionResponse The end-session response, if available.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDEndSessionCallback)(OIDEndSessionResponse *_Nullable endSessionResponse,
+                                      NSError *_Nullable error);
+
+/*! @brief Represents the type of block used as a callback for various methods of
+        @c OIDAuthorizationService.
+    @param tokenResponse The token response, if available.
+    @param error The error if an error occurred.
+ */
+typedef void (^OIDTokenCallback)(OIDTokenResponse *_Nullable tokenResponse,
+                                 NSError *_Nullable error);
+
+/*! @brief Represents the type of dictionary used to specify additional querystring parameters
+        when making authorization or token endpoint requests.
+ */
+typedef NSDictionary<NSString *, NSString *> *_Nullable OIDTokenEndpointParameters;
+
+/*! @brief Represents the type of block used as a callback for various methods of
+        @c OIDAuthorizationService.
+    @param registrationResponse The registration response, if available.
+    @param error The error if an error occurred.
+*/
+typedef void (^OIDRegistrationCompletion)(OIDRegistrationResponse *_Nullable registrationResponse,
+                                          NSError *_Nullable error);
+
+/*! @brief Performs various OAuth and OpenID Connect related calls via the user agent or
+        \NSURLSession.
+ */
+@interface OIDAuthorizationService : NSObject
+
+/*! @brief The service's configuration.
+    @remarks Each authorization service is initialized with a configuration. This configuration
+        specifies how to connect to a particular OAuth provider. Clients should use separate
+        authorization service instances for each provider they wish to integrate with.
+        Configurations may be created manually, or via an OpenID Connect Discovery Document.
+ */
+@property(nonatomic, readonly) OIDServiceConfiguration *configuration;
+
+/*! @internal
+    @brief Unavailable. This class should not be initialized.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Convenience method for creating an authorization service configuration from an OpenID
+        Connect compliant issuer URL.
+    @param issuerURL The service provider's OpenID Connect issuer.
+    @param completion A block which will be invoked when the authorization service configuration has
+        been created, or when an error has occurred.
+    @see https://openid.net/specs/openid-connect-discovery-1_0.html
+ */
++ (void)discoverServiceConfigurationForIssuer:(NSURL *)issuerURL
+                                   completion:(OIDDiscoveryCallback)completion;
+
+
+/*! @brief Convenience method for creating an authorization service configuration from an OpenID
+        Connect compliant identity provider's discovery document.
+    @param discoveryURL The URL of the service provider's OpenID Connect discovery document.
+    @param completion A block which will be invoked when the authorization service configuration has
+        been created, or when an error has occurred.
+    @see https://openid.net/specs/openid-connect-discovery-1_0.html
+ */
++ (void)discoverServiceConfigurationForDiscoveryURL:(NSURL *)discoveryURL
+                                         completion:(OIDDiscoveryCallback)completion;
+
+/*! @brief Perform an authorization flow using a generic flow shim.
+    @param request The authorization request.
+    @param externalUserAgent Generic external user-agent that can present an authorization
+        request.
+    @param callback The method called when the request has completed or failed.
+    @return A @c OIDExternalUserAgentSession instance which will terminate when it
+        receives a @c OIDExternalUserAgentSession.cancel message, or after processing a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message.
+ */
++ (id<OIDExternalUserAgentSession>) presentAuthorizationRequest:(OIDAuthorizationRequest *)request
+    externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+             callback:(OIDAuthorizationCallback)callback;
+
+/*! @brief Perform a logout request.
+    @param request The end-session logout request.
+    @param externalUserAgent Generic external user-agent that can present user-agent requests.
+    @param callback The method called when the request has completed or failed.
+    @return A @c OIDExternalUserAgentSession instance which will terminate when it
+        receives a @c OIDExternalUserAgentSession.cancel message, or after processing a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message.
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
++ (id<OIDExternalUserAgentSession>)
+    presentEndSessionRequest:(OIDEndSessionRequest *)request
+           externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                    callback:(OIDEndSessionCallback)callback;
+
+/*! @brief Performs a token request.
+    @param request The token request.
+    @param callback The method called when the request has completed or failed.
+ */
++ (void)performTokenRequest:(OIDTokenRequest *)request callback:(OIDTokenCallback)callback;
+
+/*! @brief Performs a token request.
+    @param request The token request.
+    @param authorizationResponse The original authorization response related to this token request.
+    @param callback The method called when the request has completed or failed.
+ */
++ (void)performTokenRequest:(OIDTokenRequest *)request
+    originalAuthorizationResponse:(OIDAuthorizationResponse *_Nullable)authorizationResponse
+                         callback:(OIDTokenCallback)callback;
+
+/*! @brief Performs a registration request.
+    @param request The registration request.
+    @param completion The method called when the request has completed or failed.
+ */
++ (void)performRegistrationRequest:(OIDRegistrationRequest *)request
+                        completion:(OIDRegistrationCompletion)completion;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDAuthorizationService.m

@@ -0,0 +1,790 @@
+/*! @file OIDAuthorizationService.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDAuthorizationService.h"
+
+#import "OIDAuthorizationRequest.h"
+#import "OIDAuthorizationResponse.h"
+#import "OIDDefines.h"
+#import "OIDEndSessionRequest.h"
+#import "OIDEndSessionResponse.h"
+#import "OIDErrorUtilities.h"
+#import "OIDExternalUserAgent.h"
+#import "OIDExternalUserAgentSession.h"
+#import "OIDIDToken.h"
+#import "OIDRegistrationRequest.h"
+#import "OIDRegistrationResponse.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDServiceDiscovery.h"
+#import "OIDTokenRequest.h"
+#import "OIDTokenResponse.h"
+#import "OIDURLQueryComponent.h"
+#import "OIDURLSessionProvider.h"
+
+/*! @brief Path appended to an OpenID Connect issuer for discovery
+    @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig
+ */
+static NSString *const kOpenIDConfigurationWellKnownPath = @".well-known/openid-configuration";
+
+/*! @brief Max allowable iat (Issued At) time skew
+    @see https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation
+ */
+static int const kOIDAuthorizationSessionIATMaxSkew = 600;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OIDAuthorizationSession : NSObject<OIDExternalUserAgentSession>
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (instancetype)initWithRequest:(OIDAuthorizationRequest *)request
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+@implementation OIDAuthorizationSession {
+  OIDAuthorizationRequest *_request;
+  id<OIDExternalUserAgent> _externalUserAgent;
+  OIDAuthorizationCallback _pendingauthorizationFlowCallback;
+}
+
+- (instancetype)initWithRequest:(OIDAuthorizationRequest *)request {
+  self = [super init];
+  if (self) {
+    _request = [request copy];
+  }
+  return self;
+}
+
+- (void)presentAuthorizationWithExternalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                                         callback:(OIDAuthorizationCallback)authorizationFlowCallback {
+  _externalUserAgent = externalUserAgent;
+  _pendingauthorizationFlowCallback = authorizationFlowCallback;
+  BOOL authorizationFlowStarted =
+      [_externalUserAgent presentExternalUserAgentRequest:_request session:self];
+  if (!authorizationFlowStarted) {
+    NSError *safariError = [OIDErrorUtilities errorWithCode:OIDErrorCodeSafariOpenError
+                                            underlyingError:nil
+                                                description:@"Unable to open Safari."];
+    [self didFinishWithResponse:nil error:safariError];
+  }
+}
+
+- (void)cancel {
+  [self cancelWithCompletion:nil];
+}
+
+- (void)cancelWithCompletion:(nullable void (^)(void))completion {
+  [_externalUserAgent dismissExternalUserAgentAnimated:YES completion:^{
+      NSError *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                                        underlyingError:nil
+                                            description:@"Authorization flow was cancelled."];
+      [self didFinishWithResponse:nil error:error];
+      if (completion) completion();
+  }];
+}
+
+/*! @brief Does the redirection URL equal another URL down to the path component?
+    @param URL The first redirect URI to compare.
+    @param redirectionURL The second redirect URI to compare.
+    @return YES if the URLs match down to the path level (query params are ignored).
+ */
++ (BOOL)URL:(NSURL *)URL matchesRedirectionURL:(NSURL *)redirectionURL {
+  NSURL *standardizedURL = [URL standardizedURL];
+  NSURL *standardizedRedirectURL = [redirectionURL standardizedURL];
+
+  return [standardizedURL.scheme caseInsensitiveCompare:standardizedRedirectURL.scheme] == NSOrderedSame
+      && OIDIsEqualIncludingNil(standardizedURL.user, standardizedRedirectURL.user)
+      && OIDIsEqualIncludingNil(standardizedURL.password, standardizedRedirectURL.password)
+      && OIDIsEqualIncludingNil(standardizedURL.host, standardizedRedirectURL.host)
+      && OIDIsEqualIncludingNil(standardizedURL.port, standardizedRedirectURL.port)
+      && OIDIsEqualIncludingNil(standardizedURL.path, standardizedRedirectURL.path);
+}
+
+- (BOOL)shouldHandleURL:(NSURL *)URL {
+  return [[self class] URL:URL matchesRedirectionURL:_request.redirectURL];
+}
+
+- (BOOL)resumeExternalUserAgentFlowWithURL:(NSURL *)URL {
+  // rejects URLs that don't match redirect (these may be completely unrelated to the authorization)
+  if (![self shouldHandleURL:URL]) {
+    return NO;
+  }
+  
+  AppAuthRequestTrace(@"Authorization Response: %@", URL);
+  
+  // checks for an invalid state
+  if (!_pendingauthorizationFlowCallback) {
+    [NSException raise:OIDOAuthExceptionInvalidAuthorizationFlow
+                format:@"%@", OIDOAuthExceptionInvalidAuthorizationFlow, nil];
+  }
+
+  OIDURLQueryComponent *query = [[OIDURLQueryComponent alloc] initWithURL:URL];
+
+  NSError *error;
+  OIDAuthorizationResponse *response = nil;
+
+  // checks for an OAuth error response as per RFC6749 Section 4.1.2.1
+  if (query.dictionaryValue[OIDOAuthErrorFieldError]) {
+    error = [OIDErrorUtilities OAuthErrorWithDomain:OIDOAuthAuthorizationErrorDomain
+                                      OAuthResponse:query.dictionaryValue
+                                    underlyingError:nil];
+  }
+
+  // no error, should be a valid OAuth 2.0 response
+  if (!error) {
+    response = [[OIDAuthorizationResponse alloc] initWithRequest:_request
+                                                      parameters:query.dictionaryValue];
+      
+    // verifies that the state in the response matches the state in the request, or both are nil
+    if (!OIDIsEqualIncludingNil(_request.state, response.state)) {
+      NSMutableDictionary *userInfo = [query.dictionaryValue mutableCopy];
+      userInfo[NSLocalizedDescriptionKey] =
+        [NSString stringWithFormat:@"State mismatch, expecting %@ but got %@ in authorization "
+                                   "response %@",
+                                   _request.state,
+                                   response.state,
+                                   response];
+      response = nil;
+      error = [NSError errorWithDomain:OIDOAuthAuthorizationErrorDomain
+                                  code:OIDErrorCodeOAuthAuthorizationClientError
+                              userInfo:userInfo];
+      }
+  }
+
+  [_externalUserAgent dismissExternalUserAgentAnimated:YES completion:^{
+      [self didFinishWithResponse:response error:error];
+  }];
+
+  return YES;
+}
+
+- (void)failExternalUserAgentFlowWithError:(NSError *)error {
+  [self didFinishWithResponse:nil error:error];
+}
+
+/*! @brief Invokes the pending callback and performs cleanup.
+    @param response The authorization response, if any to return to the callback.
+    @param error The error, if any, to return to the callback.
+ */
+- (void)didFinishWithResponse:(nullable OIDAuthorizationResponse *)response
+                        error:(nullable NSError *)error {
+  OIDAuthorizationCallback callback = _pendingauthorizationFlowCallback;
+  _pendingauthorizationFlowCallback = nil;
+  _externalUserAgent = nil;
+  if (callback) {
+    callback(response, error);
+  }
+}
+
+@end
+
+@interface OIDEndSessionImplementation : NSObject<OIDExternalUserAgentSession> {
+  // private variables
+  OIDEndSessionRequest *_request;
+  id<OIDExternalUserAgent> _externalUserAgent;
+  OIDEndSessionCallback _pendingEndSessionCallback;
+}
+- (instancetype)init NS_UNAVAILABLE;
+
+- (instancetype)initWithRequest:(OIDEndSessionRequest *)request
+    NS_DESIGNATED_INITIALIZER;
+@end
+
+
+@implementation OIDEndSessionImplementation
+
+- (instancetype)initWithRequest:(OIDEndSessionRequest *)request {
+  self = [super init];
+  if (self) {
+    _request = [request copy];
+  }
+  return self;
+}
+
+- (void)presentAuthorizationWithExternalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                                         callback:(OIDEndSessionCallback)authorizationFlowCallback {
+  _externalUserAgent = externalUserAgent;
+  _pendingEndSessionCallback = authorizationFlowCallback;
+  BOOL authorizationFlowStarted =
+      [_externalUserAgent presentExternalUserAgentRequest:_request session:self];
+  if (!authorizationFlowStarted) {
+    NSError *safariError = [OIDErrorUtilities errorWithCode:OIDErrorCodeSafariOpenError
+                                            underlyingError:nil
+                                                description:@"Unable to open Safari."];
+    [self didFinishWithResponse:nil error:safariError];
+  }
+}
+
+- (void)cancel {
+  [self cancelWithCompletion:nil];
+}
+
+- (void)cancelWithCompletion:(nullable void (^)(void))completion {
+  [_externalUserAgent dismissExternalUserAgentAnimated:YES completion:^{
+    NSError *error = [OIDErrorUtilities
+                      errorWithCode:OIDErrorCodeUserCanceledAuthorizationFlow
+                      underlyingError:nil
+                      description:nil];
+    [self didFinishWithResponse:nil error:error];
+    if (completion) completion();
+  }];
+}
+
+- (BOOL)shouldHandleURL:(NSURL *)URL {
+  // The logic of when to handle the URL is the same as for authorization requests: should match
+  // down to the path component.
+  return [[OIDAuthorizationSession class] URL:URL
+                        matchesRedirectionURL:_request.postLogoutRedirectURL];
+}
+
+- (BOOL)resumeExternalUserAgentFlowWithURL:(NSURL *)URL {
+  // rejects URLs that don't match redirect (these may be completely unrelated to the authorization)
+  if (![self shouldHandleURL:URL]) {
+    return NO;
+  }
+  // checks for an invalid state
+  if (!_pendingEndSessionCallback) {
+    [NSException raise:OIDOAuthExceptionInvalidAuthorizationFlow
+                format:@"%@", OIDOAuthExceptionInvalidAuthorizationFlow, nil];
+  }
+  
+  
+  NSError *error;
+  OIDEndSessionResponse *response = nil;
+
+  OIDURLQueryComponent *query = [[OIDURLQueryComponent alloc] initWithURL:URL];
+  response = [[OIDEndSessionResponse alloc] initWithRequest:_request
+                                                 parameters:query.dictionaryValue];
+  
+  // verifies that the state in the response matches the state in the request, or both are nil
+  if (!OIDIsEqualIncludingNil(_request.state, response.state)) {
+    NSMutableDictionary *userInfo = [query.dictionaryValue mutableCopy];
+    userInfo[NSLocalizedDescriptionKey] =
+    [NSString stringWithFormat:@"State mismatch, expecting %@ but got %@ in authorization "
+     "response %@",
+     _request.state,
+     response.state,
+     response];
+    response = nil;
+    error = [NSError errorWithDomain:OIDOAuthAuthorizationErrorDomain
+                                code:OIDErrorCodeOAuthAuthorizationClientError
+                            userInfo:userInfo];
+  }
+  
+  [_externalUserAgent dismissExternalUserAgentAnimated:YES completion:^{
+    [self didFinishWithResponse:response error:error];
+  }];
+  
+  return YES;
+}
+
+- (void)failExternalUserAgentFlowWithError:(NSError *)error {
+  [self didFinishWithResponse:nil error:error];
+}
+
+/*! @brief Invokes the pending callback and performs cleanup.
+ @param response The authorization response, if any to return to the callback.
+ @param error The error, if any, to return to the callback.
+ */
+- (void)didFinishWithResponse:(nullable OIDEndSessionResponse *)response
+                        error:(nullable NSError *)error {
+  OIDEndSessionCallback callback = _pendingEndSessionCallback;
+  _pendingEndSessionCallback = nil;
+  _externalUserAgent = nil;
+  if (callback) {
+    callback(response, error);
+  }
+}
+
+@end
+
+@implementation OIDAuthorizationService
+
++ (void)discoverServiceConfigurationForIssuer:(NSURL *)issuerURL
+                                   completion:(OIDDiscoveryCallback)completion {
+  NSURL *fullDiscoveryURL =
+      [issuerURL URLByAppendingPathComponent:kOpenIDConfigurationWellKnownPath];
+
+  [[self class] discoverServiceConfigurationForDiscoveryURL:fullDiscoveryURL
+                                                 completion:completion];
+}
+
++ (void)discoverServiceConfigurationForDiscoveryURL:(NSURL *)discoveryURL
+    completion:(OIDDiscoveryCallback)completion {
+
+  NSURLSession *session = [OIDURLSessionProvider session];
+  NSURLSessionDataTask *task =
+      [session dataTaskWithURL:discoveryURL
+             completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+    // If we got any sort of error, just report it.
+    if (error || !data) {
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Connection error fetching discovery document '%@': %@.",
+                                     discoveryURL,
+                                     error.localizedDescription];
+      error = [OIDErrorUtilities errorWithCode:OIDErrorCodeNetworkError
+                               underlyingError:error
+                                   description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, error);
+      });
+      return;
+    }
+
+    NSHTTPURLResponse *urlResponse = (NSHTTPURLResponse *)response;
+
+    // Check for non-200 status codes.
+    // https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationResponse
+    if (urlResponse.statusCode != 200) {
+      NSError *URLResponseError = [OIDErrorUtilities HTTPErrorWithHTTPResponse:urlResponse
+                                                                          data:data];
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Non-200 HTTP response (%d) fetching discovery document "
+                                     "'%@'.",
+                                     (int)urlResponse.statusCode,
+                                     discoveryURL];
+      error = [OIDErrorUtilities errorWithCode:OIDErrorCodeNetworkError
+                               underlyingError:URLResponseError
+                                   description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, error);
+      });
+      return;
+    }
+
+    // Construct an OIDServiceDiscovery with the received JSON.
+    OIDServiceDiscovery *discovery =
+        [[OIDServiceDiscovery alloc] initWithJSONData:data error:&error];
+    if (error || !discovery) {
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"JSON error parsing document at '%@': %@",
+                                     discoveryURL,
+                                     error.localizedDescription];
+      error = [OIDErrorUtilities errorWithCode:OIDErrorCodeNetworkError
+                               underlyingError:error
+                                   description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, error);
+      });
+      return;
+    }
+
+    // Create our service configuration with the discovery document and return it.
+    OIDServiceConfiguration *configuration =
+        [[OIDServiceConfiguration alloc] initWithDiscoveryDocument:discovery];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      completion(configuration, nil);
+    });
+  }];
+  [task resume];
+}
+
+#pragma mark - Authorization Endpoint
+
++ (id<OIDExternalUserAgentSession>) presentAuthorizationRequest:(OIDAuthorizationRequest *)request
+    externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+             callback:(OIDAuthorizationCallback)callback {
+  
+  AppAuthRequestTrace(@"Authorization Request: %@", request);
+  
+  OIDAuthorizationSession *flowSession = [[OIDAuthorizationSession alloc] initWithRequest:request];
+  [flowSession presentAuthorizationWithExternalUserAgent:externalUserAgent callback:callback];
+  return flowSession;
+}
+
++ (id<OIDExternalUserAgentSession>)
+    presentEndSessionRequest:(OIDEndSessionRequest *)request
+           externalUserAgent:(id<OIDExternalUserAgent>)externalUserAgent
+                    callback:(OIDEndSessionCallback)callback {
+  OIDEndSessionImplementation *flowSession =
+      [[OIDEndSessionImplementation alloc] initWithRequest:request];
+  [flowSession presentAuthorizationWithExternalUserAgent:externalUserAgent callback:callback];
+  return flowSession;
+}
+
+#pragma mark - Token Endpoint
+
++ (void)performTokenRequest:(OIDTokenRequest *)request callback:(OIDTokenCallback)callback {
+  [[self class] performTokenRequest:request
+      originalAuthorizationResponse:nil
+                           callback:callback];
+}
+
++ (void)performTokenRequest:(OIDTokenRequest *)request
+    originalAuthorizationResponse:(OIDAuthorizationResponse *_Nullable)authorizationResponse
+                         callback:(OIDTokenCallback)callback {
+
+  NSURLRequest *URLRequest = [request URLRequest];
+  
+  AppAuthRequestTrace(@"Token Request: %@\nHeaders:%@\nHTTPBody: %@",
+                      URLRequest.URL,
+                      URLRequest.allHTTPHeaderFields,
+                      [[NSString alloc] initWithData:URLRequest.HTTPBody
+                                            encoding:NSUTF8StringEncoding]);
+
+  NSURLSession *session = [OIDURLSessionProvider session];
+  [[session dataTaskWithRequest:URLRequest
+              completionHandler:^(NSData *_Nullable data,
+                                  NSURLResponse *_Nullable response,
+                                  NSError *_Nullable error) {
+    if (error) {
+      // A network error or server error occurred.
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Connection error making token request to '%@': %@.",
+                                     URLRequest.URL,
+                                     error.localizedDescription];
+      NSError *returnedError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeNetworkError
+                           underlyingError:error
+                               description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        callback(nil, returnedError);
+      });
+      return;
+    }
+
+    NSHTTPURLResponse *HTTPURLResponse = (NSHTTPURLResponse *)response;
+    NSInteger statusCode = HTTPURLResponse.statusCode;
+    AppAuthRequestTrace(@"Token Response: HTTP Status %d\nHTTPBody: %@",
+                        (int)statusCode,
+                        [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
+    if (statusCode != 200) {
+      // A server error occurred.
+      NSError *serverError =
+          [OIDErrorUtilities HTTPErrorWithHTTPResponse:HTTPURLResponse data:data];
+
+      // HTTP 4xx may indicate an RFC6749 Section 5.2 error response, attempts to parse as such.
+      if (statusCode >= 400 && statusCode < 500) {
+        NSError *jsonDeserializationError;
+        NSDictionary<NSString *, NSObject<NSCopying> *> *json =
+            [NSJSONSerialization JSONObjectWithData:data options:0 error:&jsonDeserializationError];
+
+        // If the HTTP 4xx response parses as JSON and has an 'error' key, it's an OAuth error.
+        // These errors are special as they indicate a problem with the authorization grant.
+        if (json[OIDOAuthErrorFieldError]) {
+          NSError *oauthError =
+            [OIDErrorUtilities OAuthErrorWithDomain:OIDOAuthTokenErrorDomain
+                                      OAuthResponse:json
+                                    underlyingError:serverError];
+          dispatch_async(dispatch_get_main_queue(), ^{
+            callback(nil, oauthError);
+          });
+          return;
+        }
+      }
+
+      // Status code indicates this is an error, but not an RFC6749 Section 5.2 error.
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Non-200 HTTP response (%d) making token request to '%@'.",
+                                     (int)statusCode,
+                                      URLRequest.URL];
+      NSError *returnedError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeServerError
+                           underlyingError:serverError
+                               description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        callback(nil, returnedError);
+      });
+      return;
+    }
+
+    NSError *jsonDeserializationError;
+    NSDictionary<NSString *, NSObject<NSCopying> *> *json =
+        [NSJSONSerialization JSONObjectWithData:data options:0 error:&jsonDeserializationError];
+    if (jsonDeserializationError) {
+      // A problem occurred deserializing the response/JSON.
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"JSON error parsing token response: %@",
+                                     jsonDeserializationError.localizedDescription];
+      NSError *returnedError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeJSONDeserializationError
+                           underlyingError:jsonDeserializationError
+                               description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        callback(nil, returnedError);
+      });
+      return;
+    }
+
+    OIDTokenResponse *tokenResponse =
+        [[OIDTokenResponse alloc] initWithRequest:request parameters:json];
+    if (!tokenResponse) {
+      // A problem occurred constructing the token response from the JSON.
+      NSError *returnedError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeTokenResponseConstructionError
+                           underlyingError:jsonDeserializationError
+                               description:@"Token response invalid."];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        callback(nil, returnedError);
+      });
+      return;
+    }
+
+    // If an ID Token is included in the response, validates the ID Token following the rules
+    // in OpenID Connect Core Section 3.1.3.7 for features that AppAuth directly supports
+    // (which excludes rules #1, #4, #5, #7, #8, #12, and #13). Regarding rule #6, ID Tokens
+    // received by this class are received via direct communication between the Client and the Token
+    // Endpoint, thus we are exercising the option to rely only on the TLS validation. AppAuth
+    // has a zero dependencies policy, and verifying the JWT signature would add a dependency.
+    // Users of the library are welcome to perform the JWT signature verification themselves should
+    // they wish.
+    if (tokenResponse.idToken) {
+      OIDIDToken *idToken = [[OIDIDToken alloc] initWithIDTokenString:tokenResponse.idToken];
+      if (!idToken) {
+        NSError *invalidIDToken =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenParsingError
+                           underlyingError:nil
+                               description:@"ID Token parsing failed"];
+        dispatch_async(dispatch_get_main_queue(), ^{
+          callback(nil, invalidIDToken);
+        });
+        return;
+      }
+      
+      // OpenID Connect Core Section 3.1.3.7. rule #1
+      // Not supported: AppAuth does not support JWT encryption.
+
+      // OpenID Connect Core Section 3.1.3.7. rule #2
+      // Validates that the issuer in the ID Token matches that of the discovery document.
+      NSURL *issuer = tokenResponse.request.configuration.issuer;
+      if (issuer && ![idToken.issuer isEqual:issuer]) {
+        NSError *invalidIDToken =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenFailedValidationError
+                           underlyingError:nil
+                               description:@"Issuer mismatch"];
+        dispatch_async(dispatch_get_main_queue(), ^{
+          callback(nil, invalidIDToken);
+        });
+        return;
+      }
+
+      // OpenID Connect Core Section 3.1.3.7. rule #3 & Section 2 azp Claim
+      // Validates that the aud (audience) Claim contains the client ID, or that the azp
+      // (authorized party) Claim matches the client ID.
+      NSString *clientID = tokenResponse.request.clientID;
+      if (![idToken.audience containsObject:clientID] &&
+          ![idToken.claims[@"azp"] isEqualToString:clientID]) {
+        NSError *invalidIDToken =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenFailedValidationError
+                           underlyingError:nil
+                               description:@"Audience mismatch"];
+        dispatch_async(dispatch_get_main_queue(), ^{
+          callback(nil, invalidIDToken);
+        });
+        return;
+      }
+      
+      // OpenID Connect Core Section 3.1.3.7. rules #4 & #5
+      // Not supported.
+
+      // OpenID Connect Core Section 3.1.3.7. rule #6
+      // As noted above, AppAuth only supports the code flow which results in direct communication
+      // of the ID Token from the Token Endpoint to the Client, and we are exercising the option to
+      // use TSL server validation instead of checking the token signature. Users may additionally
+      // check the token signature should they wish.
+
+      // OpenID Connect Core Section 3.1.3.7. rules #7 & #8
+      // Not applicable. See rule #6.
+
+      // OpenID Connect Core Section 3.1.3.7. rule #9
+      // Validates that the current time is before the expiry time.
+      NSTimeInterval expiresAtDifference = [idToken.expiresAt timeIntervalSinceNow];
+      if (expiresAtDifference < 0) {
+        NSError *invalidIDToken =
+            [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenFailedValidationError
+                             underlyingError:nil
+                                 description:@"ID Token expired"];
+        dispatch_async(dispatch_get_main_queue(), ^{
+          callback(nil, invalidIDToken);
+        });
+        return;
+      }
+      
+      // OpenID Connect Core Section 3.1.3.7. rule #10
+      // Validates that the issued at time is not more than +/- 10 minutes on the current time.
+      NSTimeInterval issuedAtDifference = [idToken.issuedAt timeIntervalSinceNow];
+      if (fabs(issuedAtDifference) > kOIDAuthorizationSessionIATMaxSkew) {
+        NSString *message =
+            [NSString stringWithFormat:@"Issued at time is more than %d seconds before or after "
+                                        "the current time",
+                                       kOIDAuthorizationSessionIATMaxSkew];
+        NSError *invalidIDToken =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenFailedValidationError
+                           underlyingError:nil
+                               description:message];
+        dispatch_async(dispatch_get_main_queue(), ^{
+          callback(nil, invalidIDToken);
+        });
+        return;
+      }
+
+      // Only relevant for the authorization_code response type
+      if ([tokenResponse.request.grantType isEqual:OIDGrantTypeAuthorizationCode]) {
+        // OpenID Connect Core Section 3.1.3.7. rule #11
+        // Validates the nonce.
+        NSString *nonce = authorizationResponse.request.nonce;
+        if (nonce && ![idToken.nonce isEqual:nonce]) {
+          NSError *invalidIDToken =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeIDTokenFailedValidationError
+                           underlyingError:nil
+                               description:@"Nonce mismatch"];
+          dispatch_async(dispatch_get_main_queue(), ^{
+            callback(nil, invalidIDToken);
+          });
+          return;
+        }
+      }
+      
+      // OpenID Connect Core Section 3.1.3.7. rules #12
+      // ACR is not directly supported by AppAuth.
+
+      // OpenID Connect Core Section 3.1.3.7. rules #12
+      // max_age is not directly supported by AppAuth.
+    }
+
+    // Success
+    dispatch_async(dispatch_get_main_queue(), ^{
+      callback(tokenResponse, nil);
+    });
+  }] resume];
+}
+
+
+#pragma mark - Registration Endpoint
+
++ (void)performRegistrationRequest:(OIDRegistrationRequest *)request
+                          completion:(OIDRegistrationCompletion)completion {
+  NSURLRequest *URLRequest = [request URLRequest];
+  if (!URLRequest) {
+    // A problem occurred deserializing the response/JSON.
+    NSError *returnedError = [OIDErrorUtilities errorWithCode:OIDErrorCodeJSONSerializationError
+                                              underlyingError:nil
+                                                  description:@"The registration request could not "
+                                                               "be serialized as JSON."];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      completion(nil, returnedError);
+    });
+    return;
+  }
+
+  NSURLSession *session = [OIDURLSessionProvider session];
+  [[session dataTaskWithRequest:URLRequest
+              completionHandler:^(NSData *_Nullable data,
+                                  NSURLResponse *_Nullable response,
+                                  NSError *_Nullable error) {
+    if (error) {
+      // A network error or server error occurred.
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Connection error making registration request to '%@': %@.",
+                                     URLRequest.URL,
+                                     error.localizedDescription];
+      NSError *returnedError = [OIDErrorUtilities errorWithCode:OIDErrorCodeNetworkError
+                                                underlyingError:error
+                                                    description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, returnedError);
+      });
+      return;
+    }
+
+    NSHTTPURLResponse *HTTPURLResponse = (NSHTTPURLResponse *) response;
+
+    if (HTTPURLResponse.statusCode != 201 && HTTPURLResponse.statusCode != 200) {
+      // A server error occurred.
+      NSError *serverError = [OIDErrorUtilities HTTPErrorWithHTTPResponse:HTTPURLResponse
+                                                                     data:data];
+
+      // HTTP 400 may indicate an OpenID Connect Dynamic Client Registration 1.0 Section 3.3 error
+      // response, checks for that
+      if (HTTPURLResponse.statusCode == 400) {
+        NSError *jsonDeserializationError;
+        NSDictionary<NSString *, NSObject <NSCopying> *> *json =
+            [NSJSONSerialization JSONObjectWithData:data options:0 error:&jsonDeserializationError];
+
+        // if the HTTP 400 response parses as JSON and has an 'error' key, it's an OAuth error
+        // these errors are special as they indicate a problem with the authorization grant
+        if (json[OIDOAuthErrorFieldError]) {
+          NSError *oauthError =
+              [OIDErrorUtilities OAuthErrorWithDomain:OIDOAuthRegistrationErrorDomain
+                                        OAuthResponse:json
+                                      underlyingError:serverError];
+          dispatch_async(dispatch_get_main_queue(), ^{
+            completion(nil, oauthError);
+          });
+          return;
+        }
+      }
+
+      // not an OAuth error, just a generic server error
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"Non-200/201 HTTP response (%d) making registration request "
+                                     "to '%@'.",
+                                     (int)HTTPURLResponse.statusCode,
+                                     URLRequest.URL];
+      NSError *returnedError = [OIDErrorUtilities errorWithCode:OIDErrorCodeServerError
+                                                underlyingError:serverError
+                                                    description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, returnedError);
+      });
+      return;
+    }
+
+    NSError *jsonDeserializationError;
+    NSDictionary<NSString *, NSObject <NSCopying> *> *json =
+        [NSJSONSerialization JSONObjectWithData:data options:0 error:&jsonDeserializationError];
+    if (jsonDeserializationError) {
+      // A problem occurred deserializing the response/JSON.
+      NSString *errorDescription =
+          [NSString stringWithFormat:@"JSON error parsing registration response: %@",
+                                     jsonDeserializationError.localizedDescription];
+      NSError *returnedError = [OIDErrorUtilities errorWithCode:OIDErrorCodeJSONDeserializationError
+                                                underlyingError:jsonDeserializationError
+                                                    description:errorDescription];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, returnedError);
+      });
+      return;
+    }
+
+    OIDRegistrationResponse *registrationResponse =
+        [[OIDRegistrationResponse alloc] initWithRequest:request
+                                              parameters:json];
+    if (!registrationResponse) {
+      // A problem occurred constructing the registration response from the JSON.
+      NSError *returnedError =
+          [OIDErrorUtilities errorWithCode:OIDErrorCodeRegistrationResponseConstructionError
+                           underlyingError:nil
+                               description:@"Registration response invalid."];
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(nil, returnedError);
+      });
+      return;
+    }
+
+    // Success
+    dispatch_async(dispatch_get_main_queue(), ^{
+      completion(registrationResponse, nil);
+    });
+  }] resume];
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDClientMetadataParameters.h

@@ -0,0 +1,51 @@
+/*! @file OIDClientMetadataParameters.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Parameter name for the token endpoint authentication method.
+ */
+extern NSString *const OIDTokenEndpointAuthenticationMethodParam;
+
+/*! @brief Parameter name for the application type.
+ */
+extern NSString *const OIDApplicationTypeParam;
+
+/*! @brief Parameter name for the redirect URI values.
+ */
+extern NSString *const OIDRedirectURIsParam;
+
+/*! @brief Parameter name for the response type values.
+ */
+extern NSString *const OIDResponseTypesParam;
+
+/*! @brief Parameter name for the grant type values.
+ */
+extern NSString *const OIDGrantTypesParam;
+
+/*! @brief Parameter name for the subject type.
+ */
+extern NSString *const OIDSubjectTypeParam;
+
+/*! @brief Application type that indicates this client is a native (not a web) application.
+ */
+extern NSString *const OIDApplicationTypeNative;
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDClientMetadataParameters.m

@@ -0,0 +1,33 @@
+/*! @file OIDClientMetadataParameters.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDClientMetadataParameters.h"
+
+NSString *const OIDTokenEndpointAuthenticationMethodParam = @"token_endpoint_auth_method";
+
+NSString *const OIDApplicationTypeParam = @"application_type";
+
+NSString *const OIDRedirectURIsParam = @"redirect_uris";
+
+NSString *const OIDResponseTypesParam = @"response_types";
+
+NSString *const OIDGrantTypesParam = @"grant_types";
+
+NSString *const OIDSubjectTypeParam = @"subject_type";
+
+NSString *const OIDApplicationTypeNative = @"native";

Pods/AppAuth/Source/AppAuthCore/OIDDefines.h

@@ -0,0 +1,51 @@
+/*! @file OIDDefines.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+/*! @def OIDIsEqualIncludingNil(x, y)
+    @brief Returns YES if x and y are equal by reference or value.
+    @discussion NOTE: parameters may be evaluated multiple times. Be careful if using this check
+        with expressions - especially if the expressions have side effects.
+    @param x An object.
+    @param y An object.
+ */
+#define OIDIsEqualIncludingNil(x, y) (((x) == (y)) || [(x) isEqual:(y)])
+
+/*! @def OID_UNAVAILABLE_USE_INITIALIZER(designatedInitializer)
+    @brief Provides a template implementation for init-family methods which have been marked as
+        NS_UNAVILABLE. Stops the compiler from giving a warning when it's the super class'
+        designated initializer, and gives callers useful feedback telling them what the
+        new designated initializer is.
+    @remarks Takes a SEL as a parameter instead of a string so that we get compiler warnings if the
+        designated intializer's signature changes.
+    @param designatedInitializer A SEL referencing the designated initializer.
+ */
+#define OID_UNAVAILABLE_USE_INITIALIZER(designatedInitializer) { \
+  NSString *reason = [NSString stringWithFormat:@"Called: %@\nDesignated Initializer:%@", \
+                                                NSStringFromSelector(_cmd), \
+                                                NSStringFromSelector(designatedInitializer)]; \
+  @throw [NSException exceptionWithName:@"Attempt to call unavailable initializer." \
+                                 reason:reason \
+                               userInfo:nil]; \
+}
+
+#ifdef _APPAUTHTRACE
+#   define AppAuthRequestTrace(fmt, ...) NSLog(fmt, ##__VA_ARGS__);
+#else // _APPAUTHTRACE
+#   define AppAuthRequestTrace(...)
+#endif // _APPAUTHTRACE
+

Pods/AppAuth/Source/AppAuthCore/OIDEndSessionRequest.h

@@ -0,0 +1,107 @@
+/*! @file OIDEndSessionRequest.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+ 
+        http://www.apache.org/licenses/LICENSE-2.0
+ 
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "OIDExternalUserAgentRequest.h"
+
+@class OIDServiceConfiguration;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OIDEndSessionRequest : NSObject
+    <NSCopying, NSSecureCoding, OIDExternalUserAgentRequest>
+
+/*! @brief The service's configuration.
+    @remarks This configuration specifies how to connect to a particular OAuth provider.
+        Configurations may be created manually, or via an OpenID Connect Discovery Document.
+ */
+@property(nonatomic, readonly) OIDServiceConfiguration *configuration;
+
+/*! @brief The client's redirect URI.
+    @remarks post_logout_redirect_uri
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
+@property(nonatomic, readonly, nullable) NSURL *postLogoutRedirectURL;
+
+/*! @brief Previously issued ID Token passed to the end session endpoint as a hint about the End-User's current authenticated
+        session with the Client
+    @remarks id_token_hint
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
+@property(nonatomic, readonly, nullable) NSString *idTokenHint;
+
+/*! @brief An opaque value used by the client to maintain state between the request and callback.
+    @remarks state
+    @discussion If this value is not explicitly set, this library will automatically add state and
+        perform appropriate validation of the state in the authorization response. It is recommended
+        that the default implementation of this parameter be used wherever possible. Typically used
+        to prevent CSRF attacks, as recommended in RFC6819 Section 5.3.5.
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
+@property(nonatomic, readonly, nullable) NSString *state;
+
+/*! @brief The client's additional authorization parameters.
+    @see https://tools.ietf.org/html/rfc6749#section-3.1
+ */
+@property(nonatomic, readonly, nullable) NSDictionary<NSString *, NSString *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithConfiguration:clientId:scopes:redirectURL:additionalParameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Creates an authorization request with opinionated defaults (a secure @c state).
+    @param configuration The service's configuration.
+    @param idTokenHint The previously issued ID Token
+    @param postLogoutRedirectURL The client's post-logout redirect URI.
+        callback.
+    @param additionalParameters The client's additional authorization parameters.
+*/
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+              idTokenHint:(NSString *)idTokenHint
+    postLogoutRedirectURL:(NSURL *)postLogoutRedirectURL
+     additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Designated initializer.
+    @param configuration The service's configuration.
+    @param idTokenHint The previously issued ID Token
+    @param postLogoutRedirectURL The client's post-logout redirect URI.
+    @param state An opaque value used by the client to maintain state between the request and
+        callback.
+    @param additionalParameters The client's additional authorization parameters.
+ */
+- (instancetype)
+    initWithConfiguration:(OIDServiceConfiguration *)configuration
+              idTokenHint:(NSString *)idTokenHint
+    postLogoutRedirectURL:(NSURL *)postLogoutRedirectURL
+                    state:(NSString *)state
+     additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Constructs the request URI by adding the request parameters to the query component of the
+        authorization endpoint URI using the "application/x-www-form-urlencoded" format.
+    @return A URL representing the authorization request.
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
+- (NSURL *)endSessionRequestURL;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDEndSessionRequest.m

@@ -0,0 +1,190 @@
+/*! @file OIDEndSessionRequest.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+ 
+        http://www.apache.org/licenses/LICENSE-2.0
+ 
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDEndSessionRequest.h"
+
+#import "OIDDefines.h"
+#import "OIDTokenUtilities.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDServiceDiscovery.h"
+#import "OIDURLQueryComponent.h"
+
+/*! @brief The key for the @c configuration property for @c NSSecureCoding
+ */
+static NSString *const kConfigurationKey = @"configuration";
+
+/*! @brief Key used to encode the @c state property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kStateKey = @"state";
+
+/*! @brief Key used to encode the @c postLogoutRedirectURL property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kPostLogoutRedirectURLKey = @"post_logout_redirect_uri";
+
+/*! @brief Key used to encode the @c idTokenHint property for @c NSSecureCoding, and on the URL request.
+ */
+static NSString *const kIdTokenHintKey = @"id_token_hint";
+
+/*! @brief Key used to encode the @c additionalParameters property for @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+/*! @brief Number of random bytes generated for the @state.
+ */
+static NSUInteger const kStateSizeBytes = 32;
+
+/*! @brief Assertion text for missing end_session_endpoint.
+ */
+static NSString *const OIDMissingEndSessionEndpointMessage =
+@"The service configuration is missing an end_session_endpoint.";
+
+@implementation OIDEndSessionRequest
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(
+        @selector(initWithConfiguration:
+                            idTokenHint:
+                  postLogoutRedirectURL:
+                   additionalParameters:)
+    )
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+                          idTokenHint:(NSString *)idTokenHint
+                postLogoutRedirectURL:(NSURL *)postLogoutRedirectURL
+                                state:(NSString *)state
+                 additionalParameters:(NSDictionary<NSString *,NSString *> *)additionalParameters
+{
+  self = [super init];
+  if (self) {
+      _configuration = [configuration copy];
+      _idTokenHint = [idTokenHint copy];
+      _postLogoutRedirectURL = [postLogoutRedirectURL copy];
+      _state = [state copy];
+      _additionalParameters =
+          [[NSDictionary alloc] initWithDictionary:additionalParameters copyItems:YES];
+  }
+  return self;
+}
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+                          idTokenHint:(NSString *)idTokenHint
+                postLogoutRedirectURL:(NSURL *)postLogoutRedirectURL
+                 additionalParameters:(NSDictionary<NSString *,NSString *> *)additionalParameters
+{
+  return [self initWithConfiguration:configuration
+                         idTokenHint:idTokenHint
+               postLogoutRedirectURL:postLogoutRedirectURL
+                               state:[[self class] generateState]
+                additionalParameters:additionalParameters];
+}
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDServiceConfiguration *configuration = [aDecoder decodeObjectOfClass:[OIDServiceConfiguration class] forKey:kConfigurationKey];
+
+  NSString *idTokenHint = [aDecoder decodeObjectOfClass:[NSString class] forKey:kIdTokenHintKey];
+  NSURL *postLogoutRedirectURL = [aDecoder decodeObjectOfClass:[NSURL class] forKey:kPostLogoutRedirectURLKey];
+  NSString *state = [aDecoder decodeObjectOfClass:[NSString class] forKey:kStateKey];
+  NSSet *additionalParameterCodingClasses = [NSSet setWithArray:@[
+                                                                  [NSDictionary class],
+                                                                  [NSString class]
+                                                                  ]];
+  NSDictionary *additionalParameters = [aDecoder decodeObjectOfClasses:additionalParameterCodingClasses
+                           forKey:kAdditionalParametersKey];
+
+  self = [self initWithConfiguration:configuration
+                         idTokenHint:idTokenHint
+               postLogoutRedirectURL:postLogoutRedirectURL
+                               state:state
+                additionalParameters:additionalParameters];
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_configuration forKey:kConfigurationKey];
+  [aCoder encodeObject:_idTokenHint forKey:kIdTokenHintKey];
+  [aCoder encodeObject:_postLogoutRedirectURL forKey:kPostLogoutRedirectURLKey];
+  [aCoder encodeObject:_state forKey:kStateKey];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, request: %@>",
+          NSStringFromClass([self class]),
+          (void *)self,
+          self.endSessionRequestURL];
+}
+
++ (nullable NSString *)generateState {
+  return [OIDTokenUtilities randomURLSafeStringWithSize:kStateSizeBytes];
+}
+
+#pragma mark - OIDExternalUserAgentRequest
+
+- (NSURL*)externalUserAgentRequestURL {
+  return [self endSessionRequestURL];
+}
+
+- (NSString *)redirectScheme {
+  return [_postLogoutRedirectURL scheme];
+}
+
+#pragma mark -
+
+- (NSURL *)endSessionRequestURL {
+  OIDURLQueryComponent *query = [[OIDURLQueryComponent alloc] init];
+
+  // Add any additional parameters the client has specified.
+  [query addParameters:_additionalParameters];
+
+  // Add optional parameters, as applicable.
+  if (_idTokenHint) {
+    [query addParameter:kIdTokenHintKey value:_idTokenHint];
+  }
+
+  if (_postLogoutRedirectURL) {
+    [query addParameter:kPostLogoutRedirectURLKey value:_postLogoutRedirectURL.absoluteString];
+  }
+
+  if (_state) {
+    [query addParameter:kStateKey value:_state];
+  }
+
+  NSAssert(_configuration.endSessionEndpoint, OIDMissingEndSessionEndpointMessage);
+
+  // Construct the URL
+  return [query URLByReplacingQueryInURL:_configuration.endSessionEndpoint];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDEndSessionResponse.h

@@ -0,0 +1,64 @@
+/*! @file OIDEndSessionResponse.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+ 
+        http://www.apache.org/licenses/LICENSE-2.0
+ 
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDEndSessionRequest;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents the response to an End Session request.
+    @see http://openid.net/specs/openid-connect-session-1_0.html#RPLogout
+ */
+
+@interface OIDEndSessionResponse : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The request which was serviced.
+ */
+@property(nonatomic, readonly) OIDEndSessionRequest *request;
+
+/*! @brief REQUIRED if the "state" parameter was present in the client end-session request. The
+        exact value received from the client.
+    @remarks state
+ */
+@property(nonatomic, readonly, nullable) NSString *state;
+
+/*! @brief Additional parameters returned from the end session endpoint.
+ */
+@property(nonatomic, readonly, nullable)
+    NSDictionary<NSString *, NSObject<NSCopying> *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use initWithParameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Designated initializer.
+    @param request The serviced request.
+    @param parameters The decoded parameters returned from the End Session Endpoint.
+    @remarks Known parameters are extracted from the @c parameters parameter and the normative
+        properties are populated. Non-normative parameters are placed in the
+        @c #additionalParameters dictionary.
+ */
+- (instancetype)initWithRequest:(OIDEndSessionRequest *)request
+                     parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters
+    NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDEndSessionResponse.m

@@ -0,0 +1,118 @@
+/*! @file OIDEndSessionResponse.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+ 
+        http://www.apache.org/licenses/LICENSE-2.0
+ 
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDEndSessionResponse.h"
+
+#import "OIDDefines.h"
+#import "OIDEndSessionRequest.h"
+#import "OIDFieldMapping.h"
+
+/*! @brief The key for the @c state property in the incoming parameters and for @c NSSecureCoding.
+ */
+static NSString *const kStateKey = @"state";
+
+/*! @brief Key used to encode the @c request property for @c NSSecureCoding
+ */
+static NSString *const kRequestKey = @"request";
+
+/*! @brief Key used to encode the @c additionalParameters property for
+ @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+@implementation OIDEndSessionResponse
+
+#pragma mark - Initializers
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithRequest:parameters:))
+
+- (instancetype)initWithRequest:(OIDEndSessionRequest *)request
+                     parameters:(NSDictionary<NSString *,NSObject<NSCopying> *> *)parameters {
+  self = [super init];
+  if (self) {
+    _request = [request copy];
+    NSDictionary<NSString *, NSObject<NSCopying> *> *additionalParameters =
+    [OIDFieldMapping remainingParametersWithMap:[[self class] fieldMap]
+                                     parameters:parameters
+                                       instance:self];
+    _additionalParameters = additionalParameters;
+  }
+  return self;
+}
+
+/*! @brief Returns a mapping of incoming parameters to instance variables.
+    @return A mapping of incoming parameters to instance variables.
+ */
++ (NSDictionary<NSString *, OIDFieldMapping *> *)fieldMap {
+  static NSMutableDictionary<NSString *, OIDFieldMapping *> *fieldMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    fieldMap = [NSMutableDictionary dictionary];
+    fieldMap[kStateKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_state" type:[NSString class]];
+  });
+  return fieldMap;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDEndSessionRequest *request =
+      [aDecoder decodeObjectOfClass:[OIDEndSessionRequest class] forKey:kRequestKey];
+  self = [self initWithRequest:request parameters:@{ }];
+  if (self) {
+    [OIDFieldMapping decodeWithCoder:aDecoder map:[[self class] fieldMap] instance:self];
+    _additionalParameters = [aDecoder decodeObjectOfClasses:[OIDFieldMapping JSONTypes]
+                                                     forKey:kAdditionalParametersKey];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_request forKey:kRequestKey];
+  [OIDFieldMapping encodeWithCoder:aCoder map:[[self class] fieldMap] instance:self];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, state: \"%@\", "
+          "additionalParameters: %@, request: %@>",
+          NSStringFromClass([self class]),
+          (void *)self,
+          _state,
+          _additionalParameters,
+          _request];
+}
+@end

Pods/AppAuth/Source/AppAuthCore/OIDError.h

@@ -0,0 +1,393 @@
+/*! @file OIDError.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief The error domain for all NSErrors returned from the AppAuth library.
+ */
+extern NSString *const OIDGeneralErrorDomain;
+
+/*! @brief The error domain for OAuth specific errors on the authorization endpoint.
+    @discussion This error domain is used when the server responds to an authorization request
+        with an explicit OAuth error, as defined by RFC6749 Section 4.1.2.1. If the authorization
+        response is invalid and not explicitly an error response, another error domain will be used.
+        The error response parameter dictionary is available in the
+        \NSError_userInfo dictionary using the @c ::OIDOAuthErrorResponseErrorKey key.
+        The \NSError_code will be one of the @c ::OIDErrorCodeOAuthAuthorization enum values.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+ */
+extern NSString *const OIDOAuthAuthorizationErrorDomain;
+
+/*! @brief The error domain for OAuth specific errors on the token endpoint.
+    @discussion This error domain is used when the server responds with HTTP 400 and an OAuth error,
+        as defined RFC6749 Section 5.2. If an HTTP 400 response does not parse as an OAuth error
+        (i.e. no 'error' field is present or the JSON is invalid), another error domain will be
+        used. The entire OAuth error response dictionary is available in the \NSError_userInfo
+        dictionary using the @c ::OIDOAuthErrorResponseErrorKey key. Unlike transient network
+        errors, errors in this domain invalidate the authentication state, and either indicate a
+        client error or require user interaction (i.e. reauthentication) to resolve.
+        The \NSError_code will be one of the @c ::OIDErrorCodeOAuthToken enum values.
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+extern NSString *const OIDOAuthTokenErrorDomain;
+
+/*! @brief The error domain for dynamic client registration errors.
+    @discussion This error domain is used when the server responds with HTTP 400 and an OAuth error,
+         as defined in OpenID Connect Dynamic Client Registration 1.0 Section 3.3. If an HTTP 400
+         response does not parse as an OAuth error (i.e. no 'error' field is present or the JSON is
+         invalid), another error domain will be  used. The entire OAuth error response dictionary is
+         available in the \NSError_userInfo dictionary using the @c ::OIDOAuthErrorResponseErrorKey
+         key. Unlike transient network errors, errors in this domain invalidate the authentication
+         state, and indicates a client error.
+         The \NSError_code will be one of the @c ::OIDErrorCodeOAuthToken enum values.
+     @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+ */
+extern NSString *const OIDOAuthRegistrationErrorDomain;
+
+/*! @brief The error domain for authorization errors encountered out of band on the resource server.
+ */
+extern NSString *const OIDResourceServerAuthorizationErrorDomain;
+
+/*! @brief An error domain representing received HTTP errors.
+ */
+extern NSString *const OIDHTTPErrorDomain;
+
+/*! @brief An error key for the original OAuth error response (if any).
+ */
+extern NSString *const OIDOAuthErrorResponseErrorKey;
+
+/*! @brief The key of the 'error' response field in a RFC6749 Section 5.2 response.
+    @remark error
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+extern NSString *const OIDOAuthErrorFieldError;
+
+/*! @brief The key of the 'error_description' response field in a RFC6749 Section 5.2 response.
+    @remark error_description
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+extern NSString *const OIDOAuthErrorFieldErrorDescription;
+
+/*! @brief The key of the 'error_uri' response field in a RFC6749 Section 5.2 response.
+    @remark error_uri
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+extern NSString *const OIDOAuthErrorFieldErrorURI;
+
+/*! @brief The various error codes returned from the AppAuth library.
+ */
+typedef NS_ENUM(NSInteger, OIDErrorCode) {
+  /*! @brief Indicates a problem parsing an OpenID Connect Service Discovery document.
+   */
+  OIDErrorCodeInvalidDiscoveryDocument = -2,
+
+  /*! @brief Indicates the user manually canceled the OAuth authorization code flow.
+   */
+  OIDErrorCodeUserCanceledAuthorizationFlow = -3,
+
+  /*! @brief Indicates an OAuth authorization flow was programmatically cancelled.
+   */
+  OIDErrorCodeProgramCanceledAuthorizationFlow = -4,
+
+  /*! @brief Indicates a network error or server error occurred.
+   */
+  OIDErrorCodeNetworkError = -5,
+
+  /*! @brief Indicates a server error occurred.
+   */
+  OIDErrorCodeServerError = -6,
+
+  /*! @brief Indicates a problem occurred deserializing the response/JSON.
+   */
+  OIDErrorCodeJSONDeserializationError = -7,
+
+  /*! @brief Indicates a problem occurred constructing the token response from the JSON.
+   */
+  OIDErrorCodeTokenResponseConstructionError = -8,
+
+  /*! @brief @c UIApplication.openURL: returned NO when attempting to open the authorization
+          request in mobile Safari.
+   */
+  OIDErrorCodeSafariOpenError = -9,
+
+  /*! @brief @c NSWorkspace.openURL returned NO when attempting to open the authorization
+          request in the default browser.
+   */
+  OIDErrorCodeBrowserOpenError = -10,
+
+  /*! @brief Indicates a problem when trying to refresh the tokens.
+   */
+  OIDErrorCodeTokenRefreshError = -11,
+
+  /*! @brief Indicates a problem occurred constructing the registration response from the JSON.
+   */
+  OIDErrorCodeRegistrationResponseConstructionError = -12,
+
+  /*! @brief Indicates a problem occurred deserializing the response/JSON.
+   */
+  OIDErrorCodeJSONSerializationError = -13,
+
+  /*! @brief The ID Token did not parse.
+   */
+  OIDErrorCodeIDTokenParsingError = -14,
+
+  /*! @brief The ID Token did not pass validation (e.g. issuer, audience checks).
+   */
+  OIDErrorCodeIDTokenFailedValidationError = -15,
+};
+
+/*! @brief Enum of all possible OAuth error codes as defined by RFC6749
+    @discussion Used by @c ::OIDErrorCodeOAuthAuthorization and @c ::OIDErrorCodeOAuthToken
+        which define endpoint-specific subsets of OAuth codes. Those enum types are down-castable
+        to this one.
+    @see https://tools.ietf.org/html/rfc6749#section-11.4
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+typedef NS_ENUM(NSInteger, OIDErrorCodeOAuth) {
+
+  /*! @remarks invalid_request
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthInvalidRequest = -2,
+
+  /*! @remarks unauthorized_client
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthUnauthorizedClient = -3,
+
+  /*! @remarks access_denied
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAccessDenied = -4,
+
+  /*! @remarks unsupported_response_type
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthUnsupportedResponseType = -5,
+
+  /*! @remarks invalid_scope
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthInvalidScope = -6,
+
+  /*! @remarks server_error
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthServerError = -7,
+
+  /*! @remarks temporarily_unavailable
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthTemporarilyUnavailable = -8,
+
+  /*! @remarks invalid_client
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthInvalidClient = -9,
+
+  /*! @remarks invalid_grant
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthInvalidGrant = -10,
+
+  /*! @remarks unsupported_grant_type
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthUnsupportedGrantType = -11,
+
+  /*! @remarks invalid_redirect_uri
+      @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+   */
+  OIDErrorCodeOAuthInvalidRedirectURI = -12,
+
+  /*! @remarks invalid_client_metadata
+      @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+   */
+  OIDErrorCodeOAuthInvalidClientMetadata = -13,
+
+  /*! @brief An authorization error occurring on the client rather than the server. For example,
+        due to a state mismatch or misconfiguration. Should be treated as an unrecoverable
+        authorization error.
+   */
+  OIDErrorCodeOAuthClientError = -0xEFFF,
+
+  /*! @brief An OAuth error not known to this library
+      @discussion Indicates an OAuth error as per RFC6749, but the error code was not in our
+          list. It could be a custom error code, or one from an OAuth extension. See the "error" key
+          of the \NSError_userInfo property. Such errors are assumed to invalidate the
+          authentication state
+   */
+  OIDErrorCodeOAuthOther = -0xF000,
+};
+
+/*! @brief The error codes for the @c ::OIDOAuthAuthorizationErrorDomain error domain
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+ */
+typedef NS_ENUM(NSInteger, OIDErrorCodeOAuthAuthorization) {
+  /*! @remarks invalid_request
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationInvalidRequest = OIDErrorCodeOAuthInvalidRequest,
+
+  /*! @remarks unauthorized_client
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationUnauthorizedClient = OIDErrorCodeOAuthUnauthorizedClient,
+
+  /*! @remarks access_denied
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationAccessDenied =
+      OIDErrorCodeOAuthAccessDenied,
+
+  /*! @remarks unsupported_response_type
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationUnsupportedResponseType =
+      OIDErrorCodeOAuthUnsupportedResponseType,
+
+  /*! @brief Indicates a network error or server error occurred.
+      @remarks invalid_scope
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationAuthorizationInvalidScope = OIDErrorCodeOAuthInvalidScope,
+
+  /*! @brief Indicates a server error occurred.
+      @remarks server_error
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationServerError = OIDErrorCodeOAuthServerError,
+
+  /*! @remarks temporarily_unavailable
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationTemporarilyUnavailable = OIDErrorCodeOAuthTemporarilyUnavailable,
+
+  /*! @brief An authorization error occurring on the client rather than the server. For example,
+        due to a state mismatch or client misconfiguration. Should be treated as an unrecoverable
+        authorization error.
+   */
+  OIDErrorCodeOAuthAuthorizationClientError = OIDErrorCodeOAuthClientError,
+
+  /*! @brief An authorization OAuth error not known to this library
+      @discussion this indicates an OAuth error as per RFC6749, but the error code was not in our
+          list. It could be a custom error code, or one from an OAuth extension. See the "error" key
+          of the \NSError_userInfo property. We assume such errors are not transient.
+      @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+   */
+  OIDErrorCodeOAuthAuthorizationOther = OIDErrorCodeOAuthOther,
+};
+
+
+/*! @brief The error codes for the @c ::OIDOAuthTokenErrorDomain error domain
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
+typedef NS_ENUM(NSInteger, OIDErrorCodeOAuthToken) {
+  /*! @remarks invalid_request
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenInvalidRequest = OIDErrorCodeOAuthInvalidRequest,
+
+  /*! @remarks invalid_client
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenInvalidClient = OIDErrorCodeOAuthInvalidClient,
+
+  /*! @remarks invalid_grant
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenInvalidGrant = OIDErrorCodeOAuthInvalidGrant,
+
+  /*! @remarks unauthorized_client
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenUnauthorizedClient = OIDErrorCodeOAuthUnauthorizedClient,
+
+  /*! @remarks unsupported_grant_type
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenUnsupportedGrantType = OIDErrorCodeOAuthUnsupportedGrantType,
+
+  /*! @remarks invalid_scope
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenInvalidScope = OIDErrorCodeOAuthInvalidScope,
+
+  /*! @brief An unrecoverable token error occurring on the client rather than the server.
+   */
+  OIDErrorCodeOAuthTokenClientError = OIDErrorCodeOAuthClientError,
+
+  /*! @brief A token endpoint OAuth error not known to this library
+      @discussion this indicates an OAuth error as per RFC6749, but the error code was not in our
+          list. It could be a custom error code, or one from an OAuth extension. See the "error" key
+          of the \NSError_userInfo property. We assume such errors are not transient.
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthTokenOther = OIDErrorCodeOAuthOther,
+};
+
+/*! @brief The error codes for the @c ::OIDOAuthRegistrationErrorDomain error domain
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+ */
+typedef NS_ENUM(NSInteger, OIDErrorCodeOAuthRegistration) {
+  /*! @remarks invalid_request
+      @see http://tools.ietf.org/html/rfc6750#section-3.1
+   */
+  OIDErrorCodeOAuthRegistrationInvalidRequest = OIDErrorCodeOAuthInvalidRequest,
+
+  /*! @remarks invalid_redirect_uri
+      @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+   */
+  OIDErrorCodeOAuthRegistrationInvalidRedirectURI = OIDErrorCodeOAuthInvalidRedirectURI,
+
+  /*! @remarks invalid_client_metadata
+      @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationError
+   */
+  OIDErrorCodeOAuthRegistrationInvalidClientMetadata = OIDErrorCodeOAuthInvalidClientMetadata,
+
+  /*! @brief An unrecoverable token error occurring on the client rather than the server.
+   */
+  OIDErrorCodeOAuthRegistrationClientError = OIDErrorCodeOAuthClientError,
+
+  /*! @brief A registration endpoint OAuth error not known to this library
+      @discussion this indicates an OAuth error, but the error code was not in our
+          list. It could be a custom error code, or one from an OAuth extension. See the "error" key
+          of the \NSError_userInfo property. We assume such errors are not transient.
+      @see https://tools.ietf.org/html/rfc6749#section-5.2
+   */
+  OIDErrorCodeOAuthRegistrationOther = OIDErrorCodeOAuthOther,
+};
+
+
+/*! @brief The exception text for the exception which occurs when a
+        @c OIDExternalUserAgentSession receives a message after it has already completed.
+ */
+extern NSString *const OIDOAuthExceptionInvalidAuthorizationFlow;
+
+/*! @brief The text for the exception which occurs when a Token Request is constructed
+        with a null redirectURL for a grant_type that requires a nonnull Redirect
+ */
+extern NSString *const OIDOAuthExceptionInvalidTokenRequestNullRedirectURL;
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDError.m

@@ -0,0 +1,45 @@
+/*! @file OIDError.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDError.h"
+
+NSString *const OIDGeneralErrorDomain = @"org.openid.appauth.general";
+
+NSString *const OIDOAuthTokenErrorDomain = @"org.openid.appauth.oauth_token";
+
+NSString *const OIDOAuthAuthorizationErrorDomain = @"org.openid.appauth.oauth_authorization";
+
+NSString *const OIDOAuthRegistrationErrorDomain = @"org.openid.appauth.oauth_registration";
+
+NSString *const OIDResourceServerAuthorizationErrorDomain = @"org.openid.appauth.resourceserver";
+
+NSString *const OIDHTTPErrorDomain = @"org.openid.appauth.remote-http";
+
+NSString *const OIDOAuthExceptionInvalidAuthorizationFlow = @"An OAuth redirect was sent to a "
+    "OIDExternalUserAgentSession after it already completed.";
+
+NSString *const OIDOAuthExceptionInvalidTokenRequestNullRedirectURL = @"A OIDTokenRequest was "
+    "created with a grant_type that requires a redirectURL, but a null redirectURL was given";
+
+NSString *const OIDOAuthErrorResponseErrorKey = @"OIDOAuthErrorResponseErrorKey";
+
+NSString *const OIDOAuthErrorFieldError = @"error";
+
+NSString *const OIDOAuthErrorFieldErrorDescription = @"error_description";
+
+NSString *const OIDOAuthErrorFieldErrorURI = @"error_uri";

Pods/AppAuth/Source/AppAuthCore/OIDErrorUtilities.h

@@ -0,0 +1,107 @@
+/*! @file OIDErrorUtilities.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "OIDError.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Convenience methods for creating standardized \NSError instances.
+ */
+@interface OIDErrorUtilities : NSObject
+
+/*! @brief Creates a standard \NSError from an @c ::OIDErrorCode and custom user info.
+        Automatically populates the localized error description.
+    @param code The error code.
+    @param underlyingError The underlying error which occurred, if applicable.
+    @param description A custom description, if applicable.
+    @return An \NSError representing the error code.
+ */
++ (NSError *)errorWithCode:(OIDErrorCode)code
+           underlyingError:(nullable NSError *)underlyingError
+               description:(nullable NSString *)description;
+
+/*! @brief Creates a standard \NSError from an @c ::OIDErrorCode and custom user info.
+        Automatically populates the localized error description.
+    @param OAuthErrorDomain The OAuth error domain. Must be @c ::OIDOAuthAuthorizationErrorDomain or
+        @c ::OIDOAuthTokenErrorDomain.
+    @param errorResponse The dictionary from an OAuth error response (as per RFC6749 Section 5.2).
+    @param underlyingError The underlying error which occurred, if applicable.
+    @return An \NSError representing the OAuth error.
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
++ (NSError *)OAuthErrorWithDomain:(NSString *)OAuthErrorDomain
+                    OAuthResponse:(NSDictionary *)errorResponse
+                  underlyingError:(nullable NSError *)underlyingError;
+
+/*! @brief Creates a \NSError indicating that the resource server responded with an authorization
+        error.
+    @param code Your error code.
+    @param errorResponse The resource server error response, if any.
+    @param underlyingError The underlying error which occurred, if applicable.
+    @return An \NSError representing the authorization error from the resource server.
+ */
++ (NSError *)resourceServerAuthorizationErrorWithCode:(NSInteger)code
+                                        errorResponse:(nullable NSDictionary *)errorResponse
+                                      underlyingError:(nullable NSError *)underlyingError;
+
+
+/*! @brief Creates a standard \NSError from an \NSHTTPURLResponse. Automatically
+        populates the localized error description with the response data associated with the
+        \NSHTTPURLResponse, if available.
+    @param HTTPURLResponse The response which indicates an error occurred.
+    @param data The response data associated with the response which should be converted to an
+        @c NSString assuming a UTF-8 encoding, if available.
+    @return An \NSError representing the error.
+ */
++ (NSError *)HTTPErrorWithHTTPResponse:(NSHTTPURLResponse *)HTTPURLResponse
+                                  data:(nullable NSData *)data;
+
+/*! @brief Raises an exception with the given name as both the name, and the message.
+    @param name The name of the exception.
+ */
++ (void)raiseException:(NSString *)name;
+
+/*! @brief Raises an exception with the given name and message.
+    @param name The name of the exception.
+    @param message The message of the exception.
+ */
++ (void)raiseException:(NSString *)name message:(NSString *)message;
+
+/*! @brief Converts an OAuth error code into an @c ::OIDErrorCodeOAuth error code.
+    @param errorCode The OAuth error code.
+    @discussion Returns @c ::OIDErrorCodeOAuthOther if the string is not in AppAuth's list.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
++ (OIDErrorCodeOAuth)OAuthErrorCodeFromString:(NSString *)errorCode;
+
+/*! @brief Returns true if the given error domain is an OAuth error domain.
+    @param errorDomain The error domain to test.
+    @discussion An OAuth error domain is used for errors returned per RFC6749 sections 4.1.2.1 and
+        5.2. Other errors, such as network errors can also occur but they will not have an OAuth
+        error domain.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+    @see https://tools.ietf.org/html/rfc6749#section-5.2
+ */
++ (BOOL)isOAuthErrorDomain:(NSString*)errorDomain;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDErrorUtilities.m

@@ -0,0 +1,172 @@
+/*! @file OIDErrorUtilities.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDErrorUtilities.h"
+
+@implementation OIDErrorUtilities
+
++ (NSError *)errorWithCode:(OIDErrorCode)code
+           underlyingError:(NSError *)underlyingError
+               description:(NSString *)description {
+  NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+  if (underlyingError) {
+    userInfo[NSUnderlyingErrorKey] = underlyingError;
+  }
+  if (description) {
+    userInfo[NSLocalizedDescriptionKey] = description;
+  }
+  // TODO: Populate localized description based on code.
+  NSError *error = [NSError errorWithDomain:OIDGeneralErrorDomain
+                                       code:code
+                                   userInfo:userInfo];
+  return error;
+}
+
++ (BOOL)isOAuthErrorDomain:(NSString *)errorDomain {
+  return errorDomain == OIDOAuthRegistrationErrorDomain
+      || errorDomain == OIDOAuthAuthorizationErrorDomain
+      || errorDomain == OIDOAuthTokenErrorDomain;
+}
+
++ (NSError *)resourceServerAuthorizationErrorWithCode:(NSInteger)code
+      errorResponse:(nullable NSDictionary *)errorResponse
+    underlyingError:(nullable NSError *)underlyingError {
+  // builds the userInfo dictionary with the full OAuth response and other information
+  NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+  if (errorResponse) {
+    userInfo[OIDOAuthErrorResponseErrorKey] = errorResponse;
+  }
+  if (underlyingError) {
+    userInfo[NSUnderlyingErrorKey] = underlyingError;
+  }
+  NSError *error = [NSError errorWithDomain:OIDResourceServerAuthorizationErrorDomain
+                                       code:code
+                                   userInfo:userInfo];
+  return error;
+}
+
++ (NSError *)OAuthErrorWithDomain:(NSString *)oAuthErrorDomain
+                    OAuthResponse:(NSDictionary *)errorResponse
+                  underlyingError:(NSError *)underlyingError {
+  // not a valid OAuth error
+  if (![self isOAuthErrorDomain:oAuthErrorDomain]
+      || !errorResponse
+      || !errorResponse[OIDOAuthErrorFieldError]
+      || ![errorResponse[OIDOAuthErrorFieldError] isKindOfClass:[NSString class]]) {
+    return [[self class] errorWithCode:OIDErrorCodeNetworkError
+                       underlyingError:underlyingError
+                           description:underlyingError.localizedDescription];
+  }
+
+  // builds the userInfo dictionary with the full OAuth response and other information
+  NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+  userInfo[OIDOAuthErrorResponseErrorKey] = errorResponse;
+  if (underlyingError) {
+    userInfo[NSUnderlyingErrorKey] = underlyingError;
+  }
+
+  NSString *oauthErrorCodeString = errorResponse[OIDOAuthErrorFieldError];
+  NSString *oauthErrorMessage = nil;
+  if ([errorResponse[OIDOAuthErrorFieldErrorDescription] isKindOfClass:[NSString class]]) {
+    oauthErrorMessage = errorResponse[OIDOAuthErrorFieldErrorDescription];
+  } else {
+    oauthErrorMessage = [errorResponse[OIDOAuthErrorFieldErrorDescription] description];
+  }
+  NSString *oauthErrorURI = nil;
+  if ([errorResponse[OIDOAuthErrorFieldErrorURI] isKindOfClass:[NSString class]]) {
+    oauthErrorURI = errorResponse[OIDOAuthErrorFieldErrorURI];
+  } else {
+    oauthErrorURI = [errorResponse[OIDOAuthErrorFieldErrorURI] description];
+  }
+
+  // builds the error description, using the information supplied by the server if possible
+  NSMutableString *description = [NSMutableString string];
+  [description appendString:oauthErrorCodeString];
+  if (oauthErrorMessage) {
+    [description appendString:@": "];
+    [description appendString:oauthErrorMessage];
+  }
+  if (oauthErrorURI) {
+    if ([description length] > 0) {
+      [description appendString:@" - "];
+    }
+    [description appendString:oauthErrorURI];
+  }
+  if ([description length] == 0) {
+    // backup description
+    [description appendFormat:@"OAuth error: %@ - https://tools.ietf.org/html/rfc6749#section-5.2",
+                              oauthErrorCodeString];
+  }
+  userInfo[NSLocalizedDescriptionKey] = description;
+
+  // looks up the error code based on the "error" response param
+  OIDErrorCodeOAuth code = [[self class] OAuthErrorCodeFromString:oauthErrorCodeString];
+
+  NSError *error = [NSError errorWithDomain:oAuthErrorDomain
+                                       code:code
+                                   userInfo:userInfo];
+  return error;
+}
+
++ (NSError *)HTTPErrorWithHTTPResponse:(NSHTTPURLResponse *)HTTPURLResponse
+                                  data:(nullable NSData *)data {
+  NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+  if (data) {
+    NSString *serverResponse =
+        [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    if (serverResponse) {
+      userInfo[NSLocalizedDescriptionKey] = serverResponse;
+    }
+  }
+  NSError *serverError =
+      [NSError errorWithDomain:OIDHTTPErrorDomain
+                          code:HTTPURLResponse.statusCode
+                      userInfo:userInfo];
+  return serverError;
+}
+
++ (OIDErrorCodeOAuth)OAuthErrorCodeFromString:(NSString *)errorCode {
+  NSDictionary *errorCodes = @{
+      @"invalid_request": @(OIDErrorCodeOAuthInvalidRequest),
+      @"unauthorized_client": @(OIDErrorCodeOAuthUnauthorizedClient),
+      @"access_denied": @(OIDErrorCodeOAuthAccessDenied),
+      @"unsupported_response_type": @(OIDErrorCodeOAuthUnsupportedResponseType),
+      @"invalid_scope": @(OIDErrorCodeOAuthInvalidScope),
+      @"server_error": @(OIDErrorCodeOAuthServerError),
+      @"temporarily_unavailable": @(OIDErrorCodeOAuthTemporarilyUnavailable),
+      @"invalid_client": @(OIDErrorCodeOAuthInvalidClient),
+      @"invalid_grant": @(OIDErrorCodeOAuthInvalidGrant),
+      @"unsupported_grant_type": @(OIDErrorCodeOAuthUnsupportedGrantType),
+      };
+  NSNumber *code = errorCodes[errorCode];
+  if (code) {
+    return [code integerValue];
+  } else {
+    return OIDErrorCodeOAuthOther;
+  }
+}
+
++ (void)raiseException:(NSString *)name {
+  [[self class] raiseException:name message:name];
+}
+
++ (void)raiseException:(NSString *)name message:(NSString *)message {
+  [NSException raise:name format:@"%@", message];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDExternalUserAgent.h

@@ -0,0 +1,53 @@
+/*! @file OIDExternalUserAgent.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@protocol OIDExternalUserAgentSession;
+@protocol OIDExternalUserAgentRequest;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @protocol OIDExternalUserAgent
+    @brief An external user-agent UI that presents displays the request to the user. Clients may
+        provide custom implementations of an external user-agent to customize the way the requests
+        are presented to the end user.
+ */
+@protocol OIDExternalUserAgent<NSObject>
+
+/*! @brief Presents the request in the external user-agent.
+    @param request The request to be presented in the external user-agent.
+    @param session The @c OIDExternalUserAgentSession instance that initiates presenting the UI.
+        Concrete implementations of a @c OIDExternalUserAgent may call
+        resumeExternalUserAgentFlowWithURL or failExternalUserAgentFlowWithError on session to either
+        resume or fail the request.
+    @return YES If the request UI was successfully presented to the user.
+ */
+- (BOOL)presentExternalUserAgentRequest:(id<OIDExternalUserAgentRequest> )request
+                                session:(id<OIDExternalUserAgentSession>)session;
+
+/*! @brief Dimisses the external user-agent and calls completion when the dismiss operation ends.
+    @param animated Whether or not the dismiss operation should be animated.
+    @remarks Has no effect if no UI is presented.
+    @param completion The block to be called when the dismiss operations ends
+ */
+- (void)dismissExternalUserAgentAnimated:(BOOL)animated completion:(void (^)(void))completion;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDExternalUserAgentRequest.h

@@ -0,0 +1,37 @@
+/*! @file OIDExternalUserAgent.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+   
+        http://www.apache.org/licenses/LICENSE-2.0
+   
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+/*! @protocol OIDExternalUserAgent
+    @brief An interface that any external user-agent request may implement to use the
+        @c OIDExternalUserAgent flow.
+ */
+@protocol OIDExternalUserAgentRequest
+
+/*! @brief Method to create and return the complete request URL instance.
+    @return A @c NSURL instance which contains the URL to be opened in an external UI (i.e. browser)
+ */
+- (NSURL*)externalUserAgentRequestURL;
+
+/*! @brief If this external user-agent request has a redirect URL, this should return its scheme.
+        Since some external requests have optional callbacks (such as the end session endpoint), the
+        return value of this method is nullable.
+    @return A @c NSString instance that contains the scheme of a callback url, or nil if there is
+        no callback url for this request.
+ */
+- (NSString*)redirectScheme;
+@end

Pods/AppAuth/Source/AppAuthCore/OIDExternalUserAgentSession.h

@@ -0,0 +1,65 @@
+/*! @file OIDExternalUserAgentSession.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 The AppAuth Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+ 
+        http://www.apache.org/licenses/LICENSE-2.0
+ 
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents an in-flight external user-agent session.
+ */
+@protocol OIDExternalUserAgentSession <NSObject>
+
+/*! @brief Cancels the code flow session, invoking the request's callback with a cancelled error.
+    @remarks Has no effect if called more than once, or after a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message was received.
+        Will cause an error with code: @c ::OIDErrorCodeProgramCanceledAuthorizationFlow to be
+        passed to the @c callback block passed to
+        @c OIDAuthorizationService.presentAuthorizationRequest:presentingViewController:callback:
+ */
+- (void)cancel;
+
+/*! @brief Cancels the code flow session, invoking the request's callback with a cancelled error.
+    @remarks Has no effect if called more than once, or after a
+        @c OIDExternalUserAgentSession.resumeExternalUserAgentFlowWithURL: message was received.
+        Will cause an error with code: @c ::OIDErrorCodeProgramCanceledAuthorizationFlow to be
+        passed to the @c callback block passed to
+        @c OIDAuthorizationService.presentAuthorizationRequest:presentingViewController:callback:
+    @param completion The block to be called when the cancel operation ends
+ */
+- (void)cancelWithCompletion:(nullable void (^)(void))completion;
+
+/*! @brief Clients should call this method with the result of the external user-agent code flow if
+        it becomes available.
+    @param URL The redirect URL invoked by the server.
+    @discussion When the URL represented a valid response, implementations should clean up any
+        left-over UI state from the request, for example by closing the
+        \SFSafariViewController or loopback HTTP listener if those were used. The completion block
+        of the pending request should then be invoked.
+    @remarks Has no effect if called more than once, or after a @c cancel message was received.
+    @return YES if the passed URL matches the expected redirect URL and was consumed, NO otherwise.
+ */
+- (BOOL)resumeExternalUserAgentFlowWithURL:(NSURL *)URL;
+
+/*! @brief @c OIDExternalUserAgent or clients should call this method when the
+        external user-agent flow failed with a non-OAuth error.
+    @param error The error that is the reason for the failure of this external flow.
+    @remarks Has no effect if called more than once, or after a @c cancel message was received.
+ */
+- (void)failExternalUserAgentFlowWithError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDFieldMapping.h

@@ -0,0 +1,126 @@
+/*! @file OIDFieldMapping.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents a function which transforms incoming source values into instance variable
+        values.
+ */
+typedef _Nullable id(^OIDFieldMappingConversionFunction)(NSObject *_Nullable value);
+
+/*! @brief Describes the mapping of a key/value pair to an iVar with an optional conversion
+        function.
+ */
+@interface OIDFieldMapping : NSObject
+
+/*! @brief The name of the instance variable the field should be mapped to.
+ */
+@property(nonatomic, readonly) NSString *name;
+
+/*! @brief The type of the instance variable.
+ */
+@property(nonatomic, readonly) Class expectedType;
+
+/*! @brief An optional conversion function which specifies a transform from the incoming data to the
+        instance variable value.
+ */
+@property(nonatomic, readonly, nullable) OIDFieldMappingConversionFunction conversion;
+
+/*! @internal
+    @brief Unavailable. Please use initWithName:type:conversion:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief The designated initializer.
+    @param name The name of the instance variable the field should be mapped to.
+    @param type The type of the instance variable.
+    @param conversion An optional conversion function which specifies a transform from the incoming
+        data to the instance variable value. Used during the process performed by
+        @c OIDFieldMapping.remainingParametersWithMap:parameters:instance: but not during
+        encoding/decoding, since the encoded and decoded values should already be of the type
+        specified by the @c type parameter.
+ */
+- (instancetype)initWithName:(NSString *)name
+                        type:(Class)type
+                  conversion:(nullable OIDFieldMappingConversionFunction)conversion
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief A convenience initializer.
+    @param name The name of the instance variable the field should be mapped to.
+    @param type The type of the instance variable.
+ */
+- (instancetype)initWithName:(NSString *)name
+                        type:(Class)type;
+
+/*! @brief Performs a mapping of key/value pairs in an incoming parameters dictionary to instance
+        variables, returning a dictionary of parameter key/values which didn't map to instance
+        variables.
+    @param map A mapping of incoming keys to instance variables.
+    @param parameters Incoming key value pairs to map to an instance's variables.
+    @param instance The instance whose variables should be set based on the mapping.
+    @return A dictionary of parameter key/values which didn't map to instance variables.
+ */
++ (NSDictionary<NSString *, NSObject<NSCopying> *> *)remainingParametersWithMap:
+    (NSDictionary<NSString *, OIDFieldMapping *> *)map
+    parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters
+      instance:(id)instance;
+
+/*! @brief This helper method for @c NSCoding implementations performs a serialization of fields
+        defined in a field mapping.
+    @param aCoder An @c NSCoder instance to serialize instance variable values to.
+    @param map A mapping of keys to instance variables.
+    @param instance The instance whose variables should be serialized based on the mapping.
+ */
++ (void)encodeWithCoder:(NSCoder *)aCoder
+                    map:(NSDictionary<NSString *, OIDFieldMapping *> *)map
+               instance:(id)instance;
+
+/*! @brief This helper method for @c NSCoding implementations performs a deserialization of
+        fields defined in a field mapping.
+    @param aCoder An @c NSCoder instance from which to deserialize instance variable values from.
+    @param map A mapping of keys to instance variables.
+    @param instance The instance whose variables should be deserialized based on the mapping.
+ */
++ (void)decodeWithCoder:(NSCoder *)aCoder
+                    map:(NSDictionary<NSString *, OIDFieldMapping *> *)map
+               instance:(id)instance;
+
+/*! @brief Returns an @c NSSet of classes suitable for deserializing JSON content in an
+        @c NSSecureCoding context.
+ */
++ (NSSet *)JSONTypes;
+
+/*! @brief Returns a function for converting an @c NSString to an @c NSURL.
+ */
++ (OIDFieldMappingConversionFunction)URLConversion;
+
+/*! @brief Returns a function for converting an @c NSNumber number of seconds from now to an
+        @c NSDate.
+ */
++ (OIDFieldMappingConversionFunction)dateSinceNowConversion;
+
+/*! @brief Returns a function for converting an @c NSNumber representing a unix time stamp to an
+        @c NSDate.
+ */
++ (OIDFieldMappingConversionFunction)dateEpochConversion;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDFieldMapping.m

@@ -0,0 +1,132 @@
+/*! @file OIDFieldMapping.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDFieldMapping.h"
+
+#import "OIDDefines.h"
+
+@implementation OIDFieldMapping
+
+- (nonnull instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithName:type:conversion:))
+
+- (instancetype)initWithName:(NSString *)name
+                                 type:(Class)type {
+  return [self initWithName:name type:type conversion:nil];
+}
+
+- (instancetype)initWithName:(NSString *)name
+                                 type:(Class)type
+                           conversion:(nullable OIDFieldMappingConversionFunction)conversion {
+  self = [super init];
+  if (self) {
+    _name = [name copy];
+    _expectedType = type;
+    _conversion = conversion;
+  }
+  return self;
+}
+
++ (NSDictionary<NSString *, NSObject<NSCopying> *> *)remainingParametersWithMap:
+    (NSDictionary<NSString *, OIDFieldMapping *> *)map
+    parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters
+      instance:(id)instance {
+  NSMutableDictionary *additionalParameters = [NSMutableDictionary dictionary];
+  for (NSString *key in parameters) {
+    NSObject<NSCopying> *value = [parameters[key] copy];
+    OIDFieldMapping *mapping = map[key];
+    // If the field doesn't appear in the mapping, we add it to the additional parameters
+    // dictionary.
+    if (!mapping) {
+      additionalParameters[key] = value;
+      continue;
+    }
+    // If the field mapping specifies a conversion function, apply the conversion to the value.
+    if (mapping.conversion) {
+      value = mapping.conversion(value);
+    }
+    // Check the type of the value and make sure it matches the type we expected. If it doesn't we
+    // add the value to the additional parameters dictionary but don't assign the instance variable.
+    if (![value isKindOfClass:mapping.expectedType]) {
+      additionalParameters[key] = value;
+      continue;
+    }
+    // Assign the instance variable.
+    [instance setValue:value forKey:mapping.name];
+  }
+  return additionalParameters;
+}
+
++ (void)encodeWithCoder:(NSCoder *)aCoder
+                    map:(NSDictionary<NSString *, OIDFieldMapping *> *)map
+               instance:(id)instance {
+  for (NSString *key in map) {
+    id value = [instance valueForKey:map[key].name];
+    [aCoder encodeObject:value forKey:key];
+  }
+}
+
++ (void)decodeWithCoder:(NSCoder *)aCoder
+                    map:(NSDictionary<NSString *, OIDFieldMapping *> *)map
+               instance:(id)instance {
+  for (NSString *key in map) {
+    OIDFieldMapping *mapping = map[key];
+    id value = [aCoder decodeObjectOfClass:mapping.expectedType forKey:key];
+    [instance setValue:value forKey:mapping.name];
+  }
+}
+
++ (NSSet *)JSONTypes {
+  return [NSSet setWithArray:@[
+    [NSDictionary class],
+    [NSArray class],
+    [NSString class],
+    [NSNumber class]
+  ]];
+}
+
++ (OIDFieldMappingConversionFunction)URLConversion {
+  return ^id _Nullable(NSObject *_Nullable value) {
+    if ([value isKindOfClass:[NSString class]]) {
+      return [NSURL URLWithString:(NSString *)value];
+    }
+    return value;
+  };
+}
+
++ (OIDFieldMappingConversionFunction)dateSinceNowConversion {
+  return ^id _Nullable(NSObject *_Nullable value) {
+    if (![value isKindOfClass:[NSNumber class]]) {
+      return value;
+    }
+    NSNumber *valueAsNumber = (NSNumber *)value;
+    return [NSDate dateWithTimeIntervalSinceNow:[valueAsNumber longLongValue]];
+  };
+}
+
++ (OIDFieldMappingConversionFunction)dateEpochConversion {
+  return ^id _Nullable(NSObject *_Nullable value) {
+    if (![value isKindOfClass:[NSNumber class]]) {
+      return value;
+    }
+    NSNumber *valueAsNumber = (NSNumber *) value;
+    return [NSDate dateWithTimeIntervalSince1970:[valueAsNumber longLongValue]];
+  };
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDGrantTypes.h

@@ -0,0 +1,40 @@
+/*! @file OIDGrantTypes.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*! @brief For exchanging an authorization code for an access token.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+extern NSString *const OIDGrantTypeAuthorizationCode;
+
+/*! @brief For refreshing an access token with a refresh token.
+    @see https://tools.ietf.org/html/rfc6749#section-6
+ */
+extern NSString *const OIDGrantTypeRefreshToken;
+
+/*! @brief For obtaining an access token with a username and password.
+    @see https://tools.ietf.org/html/rfc6749#section-4.3.2
+ */
+extern NSString *const OIDGrantTypePassword;
+
+/*! @brief For obtaining an access token from the token endpoint using client credentials.
+    @see https://tools.ietf.org/html/rfc6749#section-3.2.1
+    @see https://tools.ietf.org/html/rfc6749#section-4.4.2
+ */
+extern NSString *const OIDGrantTypeClientCredentials;

Pods/AppAuth/Source/AppAuthCore/OIDGrantTypes.m

@@ -0,0 +1,27 @@
+/*! @file OIDGrantTypes.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDGrantTypes.h"
+
+NSString *const OIDGrantTypeAuthorizationCode = @"authorization_code";
+
+NSString *const OIDGrantTypeRefreshToken = @"refresh_token";
+
+NSString *const OIDGrantTypePassword = @"password";
+
+NSString *const OIDGrantTypeClientCredentials = @"client_credentials";

Pods/AppAuth/Source/AppAuthCore/OIDIDToken.h

@@ -0,0 +1,91 @@
+/*! @file OIDIDToken.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief A convenience class that parses an ID Token and extracts the claims _but does not_
+           verify its signature. AppAuth only supports the OpenID Code flow, meaning ID Tokens
+           received by AppAuth are sent from the token endpoint on a TLS protected channel,
+           offering some assurances as to the origin of the token. You may wish to additionally
+           verify the ID Token signature using a JWT signature verification library of your
+           choosing.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+    @see https://tools.ietf.org/html/rfc7519
+    @see https://jwt.io/
+ */
+@interface OIDIDToken : NSObject
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithAuthorizationResponse:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Parses the given ID Token string.
+    @param idToken The ID Token spring.
+ */
+- (nullable instancetype)initWithIDTokenString:(NSString *)idToken;
+
+/*! @brief The header JWT values.
+ */
+@property(nonatomic, readonly) NSDictionary *header;
+
+/*! @brief All ID Token claims.
+ */
+@property(nonatomic, readonly) NSDictionary *claims;
+
+/*! @brief Issuer Identifier for the Issuer of the response.
+    @remarks iss
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly) NSURL *issuer;
+
+/*! @brief Subject Identifier.
+    @remarks sub
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly) NSString *subject;
+
+/*! @brief Audience(s) that this ID Token is intended for.
+    @remarks aud
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly) NSArray *audience;
+
+/*! @brief Expiration time on or after which the ID Token MUST NOT be accepted for processing.
+    @remarks exp
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly) NSDate *expiresAt;
+
+/*! @brief Time at which the JWT was issued.
+    @remarks iat
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly) NSDate *issuedAt;
+
+/*! @brief String value used to associate a Client session with an ID Token, and to mitigate replay
+        attacks.
+    @remarks nonce
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+ */
+@property(nonatomic, readonly, nullable) NSString *nonce;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDIDToken.m

@@ -0,0 +1,149 @@
+/*! @file OIDIDToken.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2017 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDIDToken.h"
+
+/*! Field keys associated with an ID Token. */
+static NSString *const kIssKey = @"iss";
+static NSString *const kSubKey = @"sub";
+static NSString *const kAudKey = @"aud";
+static NSString *const kExpKey = @"exp";
+static NSString *const kIatKey = @"iat";
+static NSString *const kNonceKey = @"nonce";
+
+#import "OIDFieldMapping.h"
+
+@implementation OIDIDToken
+
+- (instancetype)initWithIDTokenString:(NSString *)idToken {
+  self = [super init];
+  NSArray *sections = [idToken componentsSeparatedByString:@"."];
+  
+  // The header and claims sections are required.
+  if (sections.count <= 1) {
+    return nil;
+  }
+  
+  _header = [[self class] parseJWTSection:sections[0]];
+  _claims = [[self class] parseJWTSection:sections[1]];
+  if (!_header || !_claims) {
+    return nil;
+  }
+
+  [OIDFieldMapping remainingParametersWithMap:[[self class] fieldMap]
+                                   parameters:_claims
+                                     instance:self];
+
+  // Required fields.
+  if (!_issuer || !_audience || !_subject || !_expiresAt || !_issuedAt) {
+    return nil;
+  }
+
+  return self;
+}
+
+/*! @brief Returns a mapping of incoming parameters to instance variables.
+    @return A mapping of incoming parameters to instance variables.
+ */
++ (NSDictionary<NSString *, OIDFieldMapping *> *)fieldMap {
+  static NSMutableDictionary<NSString *, OIDFieldMapping *> *fieldMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    fieldMap = [NSMutableDictionary dictionary];
+
+    fieldMap[kIssKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_issuer"
+                                         type:[NSURL class]
+                                   conversion:[OIDFieldMapping URLConversion]];
+    fieldMap[kSubKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_subject" type:[NSString class]];
+    fieldMap[kAudKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_audience"
+                                         type:[NSArray class]
+                                   conversion:^id _Nullable(NSObject *_Nullable value) {
+          if ([value isKindOfClass:[NSArray class]]) {
+            return value;
+          }
+          if ([value isKindOfClass:[NSString class]]) {
+            return @[value];
+          }
+          return nil;
+        }];
+    fieldMap[kExpKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_expiresAt"
+                                         type:[NSDate class]
+                                   conversion:^id _Nullable(NSObject *_Nullable value) {
+          if (![value isKindOfClass:[NSNumber class]]) {
+            return value;
+          }
+          NSNumber *valueAsNumber = (NSNumber *)value;
+          return [NSDate dateWithTimeIntervalSince1970:valueAsNumber.longLongValue];
+        }];
+    fieldMap[kIatKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_issuedAt"
+                                         type:[NSDate class]
+                                   conversion:^id _Nullable(NSObject *_Nullable value) {
+          if (![value isKindOfClass:[NSNumber class]]) {
+            return value;
+          }
+          NSNumber *valueAsNumber = (NSNumber *)value;
+          return [NSDate dateWithTimeIntervalSince1970:valueAsNumber.longLongValue];
+        }];
+    fieldMap[kNonceKey] =
+        [[OIDFieldMapping alloc] initWithName:@"_nonce" type:[NSString class]];
+  });
+  return fieldMap;
+}
+
++ (NSDictionary *)parseJWTSection:(NSString *)sectionString {
+  NSData *decodedData = [[self class] base64urlNoPaddingDecode:sectionString];
+
+  // Parses JSON.
+  NSError *error;
+  id object = [NSJSONSerialization JSONObjectWithData:decodedData options:0 error:&error];
+  if (error) {
+    NSLog(@"Error %@ parsing token payload %@", error, sectionString);
+  }
+  if ([object isKindOfClass:[NSDictionary class]]) {
+    return (NSDictionary *)object;
+  }
+
+  return nil;
+}
+
++ (NSData *)base64urlNoPaddingDecode:(NSString *)base64urlNoPaddingString {
+    NSMutableString *body = [base64urlNoPaddingString mutableCopy];
+
+    // Converts base64url to base64.
+    NSRange range = NSMakeRange(0, base64urlNoPaddingString.length);
+    [body replaceOccurrencesOfString:@"-" withString:@"+" options:NSLiteralSearch range:range];
+    [body replaceOccurrencesOfString:@"_" withString:@"/" options:NSLiteralSearch range:range];
+
+    // Converts base64 no padding to base64 with padding
+    while (body.length % 4 != 0) {
+      [body appendString:@"="];
+    }
+
+    // Decodes base64 string.
+    NSData *decodedData = [[NSData alloc] initWithBase64EncodedString:body options:0];
+    return decodedData;
+}
+
+@end
+
+

Pods/AppAuth/Source/AppAuthCore/OIDRegistrationRequest.h

@@ -0,0 +1,141 @@
+/*! @file OIDRegistrationRequest.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDAuthorizationResponse;
+@class OIDServiceConfiguration;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents a registration request.
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationRequest
+ */
+@interface OIDRegistrationRequest : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The service's configuration.
+    @remarks This configuration specifies how to connect to a particular OAuth provider.
+        Configurations may be created manually, or via an OpenID Connect Discovery Document.
+ */
+@property(nonatomic, readonly) OIDServiceConfiguration *configuration;
+
+/*! @brief The initial access token to access the Client Registration Endpoint
+        (if required by the OpenID Provider).
+    @remarks OAuth 2.0 Access Token optionally issued by an Authorization Server granting
+        access to its Client Registration Endpoint. This token (if required) is
+        provisioned out of band.
+    @see Section 3 of OpenID Connect Dynamic Client Registration 1.0
+        https://openid.net/specs/openid-connect-registration-1_0.html#ClientRegistration
+ */
+@property(nonatomic, readonly) NSString *initialAccessToken;
+
+/*! @brief The application type to register, will always be 'native'.
+    @remarks application_type
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
+ */
+@property(nonatomic, readonly) NSString *applicationType;
+
+/*! @brief The client's redirect URI's.
+    @remarks redirect_uris
+    @see https://tools.ietf.org/html/rfc6749#section-3.1.2
+ */
+@property(nonatomic, readonly) NSArray<NSURL *> *redirectURIs;
+
+/*! @brief The response types to register for usage by this client.
+    @remarks response_types
+    @see http://openid.net/specs/openid-connect-core-1_0.html#Authentication
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *responseTypes;
+
+/*! @brief The grant types to register for usage by this client.
+    @remarks grant_types
+ @see https://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *grantTypes;
+
+/*! @brief The subject type to to request.
+    @remarks subject_type
+    @see http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes
+ */
+@property(nonatomic, readonly, nullable) NSString *subjectType;
+
+/*! @brief The client authentication method to use at the token endpoint.
+    @remarks token_endpoint_auth_method
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication
+ */
+@property(nonatomic, readonly, nullable) NSString *tokenEndpointAuthenticationMethod;
+
+/*! @brief The client's additional token request parameters.
+ */
+@property(nonatomic, readonly, nullable) NSDictionary<NSString *, NSString *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use initWithConfiguration
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Create a Client Registration Request to an OpenID Provider that supports open Dynamic
+        Registration.
+    @param configuration The service's configuration.
+    @param redirectURIs The redirect URIs to register for the client.
+    @param responseTypes The response types to register for the client.
+    @param grantTypes The grant types to register for the client.
+    @param subjectType The subject type to register for the client.
+    @param tokenEndpointAuthMethod The token endpoint authentication method to register for the
+        client.
+    @param additionalParameters The client's additional registration request parameters.
+ */
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               redirectURIs:(NSArray<NSURL *> *)redirectURIs
+              responseTypes:(nullable NSArray<NSString *> *)responseTypes
+                 grantTypes:(nullable NSArray<NSString *> *)grantTypes
+                subjectType:(nullable NSString *)subjectType
+    tokenEndpointAuthMethod:(nullable NSString *)tokenEndpointAuthMethod
+       additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Designated initializer.
+    @param configuration The service's configuration.
+    @param redirectURIs The redirect URIs to register for the client.
+    @param responseTypes The response types to register for the client.
+    @param grantTypes The grant types to register for the client.
+    @param subjectType The subject type to register for the client.
+    @param tokenEndpointAuthMethod The token endpoint authentication method to register for the
+        client.
+    @param initialAccessToken The initial access token to access the Client Registration Endpoint
+        (if required by the OpenID Provider).
+    @param additionalParameters The client's additional registration request parameters.
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#ClientRegistration
+ */
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               redirectURIs:(NSArray<NSURL *> *)redirectURIs
+              responseTypes:(nullable NSArray<NSString *> *)responseTypes
+                 grantTypes:(nullable NSArray<NSString *> *)grantTypes
+                subjectType:(nullable NSString *)subjectType
+    tokenEndpointAuthMethod:(nullable NSString *)tokenEndpointAuthMethod
+         initialAccessToken:(nullable NSString *)initialAccessToken
+       additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Constructs an @c NSURLRequest representing the registration request.
+    @return An @c NSURLRequest representing the registration request.
+ */
+- (NSURLRequest *)URLRequest;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDRegistrationRequest.m

@@ -0,0 +1,248 @@
+/*! @file OIDRegistrationRequest.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDRegistrationRequest.h"
+
+#import "OIDClientMetadataParameters.h"
+#import "OIDDefines.h"
+#import "OIDServiceConfiguration.h"
+
+/*! @brief The key for the @c configuration property for @c NSSecureCoding
+ */
+static NSString *const kConfigurationKey = @"configuration";
+
+/*! @brief The key for the @c initialAccessToken property for @c NSSecureCoding
+ */
+static NSString *const kInitialAccessToken  = @"initial_access_token";
+
+/*! @brief Key used to encode the @c redirectURIs property for @c NSSecureCoding
+ */
+static NSString *const kRedirectURIsKey = @"redirect_uris";
+
+/*! @brief The key for the @c responseTypes property for @c NSSecureCoding.
+ */
+static NSString *const kResponseTypesKey = @"response_types";
+
+/*! @brief Key used to encode the @c grantType property for @c NSSecureCoding
+ */
+static NSString *const kGrantTypesKey = @"grant_types";
+
+/*! @brief Key used to encode the @c subjectType property for @c NSSecureCoding
+ */
+static NSString *const kSubjectTypeKey = @"subject_type";
+
+/*! @brief Key used to encode the @c additionalParameters property for
+        @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+@implementation OIDRegistrationRequest
+
+#pragma mark - Initializers
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(
+        @selector(initWithConfiguration:
+                           redirectURIs:
+                          responseTypes:
+                             grantTypes:
+                            subjectType:
+                tokenEndpointAuthMethod:
+                   additionalParameters:)
+    )
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+            redirectURIs:(NSArray<NSURL *> *)redirectURIs
+           responseTypes:(nullable NSArray<NSString *> *)responseTypes
+              grantTypes:(nullable NSArray<NSString *> *)grantTypes
+             subjectType:(nullable NSString *)subjectType
+ tokenEndpointAuthMethod:(nullable NSString *)tokenEndpointAuthenticationMethod
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  return [self initWithConfiguration:configuration
+                        redirectURIs:redirectURIs
+                       responseTypes:responseTypes
+                          grantTypes:grantTypes
+                         subjectType:subjectType
+             tokenEndpointAuthMethod:tokenEndpointAuthenticationMethod
+                  initialAccessToken:nil
+                additionalParameters:additionalParameters];
+}
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               redirectURIs:(NSArray<NSURL *> *)redirectURIs
+              responseTypes:(nullable NSArray<NSString *> *)responseTypes
+                 grantTypes:(nullable NSArray<NSString *> *)grantTypes
+                subjectType:(nullable NSString *)subjectType
+    tokenEndpointAuthMethod:(nullable NSString *)tokenEndpointAuthenticationMethod
+         initialAccessToken:(nullable NSString *)initialAccessToken
+       additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  self = [super init];
+  if (self) {
+    _configuration = [configuration copy];
+    _initialAccessToken = [initialAccessToken copy];
+    _redirectURIs = [redirectURIs copy];
+    _responseTypes = [responseTypes copy];
+    _grantTypes = [grantTypes copy];
+    _subjectType = [subjectType copy];
+    _tokenEndpointAuthenticationMethod = [tokenEndpointAuthenticationMethod copy];
+    _additionalParameters =
+        [[NSDictionary alloc] initWithDictionary:additionalParameters copyItems:YES];
+
+    _applicationType = OIDApplicationTypeNative;
+  }
+  return self;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDServiceConfiguration *configuration =
+  [aDecoder decodeObjectOfClass:[OIDServiceConfiguration class]
+                         forKey:kConfigurationKey];
+  NSString *initialAccessToken = [aDecoder decodeObjectOfClass:[NSString class]
+                                                        forKey:kInitialAccessToken];
+  NSArray<NSURL *> *redirectURIs = [aDecoder decodeObjectOfClass:[NSArray<NSURL *> class]
+                                                          forKey:kRedirectURIsKey];
+  NSArray<NSString *> *responseTypes = [aDecoder decodeObjectOfClass:[NSArray<NSString *> class]
+                                                              forKey:kResponseTypesKey];
+  NSArray<NSString *> *grantTypes = [aDecoder decodeObjectOfClass:[NSArray<NSString *> class]
+                                                           forKey:kGrantTypesKey];
+  NSString *subjectType = [aDecoder decodeObjectOfClass:[NSString class]
+                                                 forKey:kSubjectTypeKey];
+  NSString *tokenEndpointAuthenticationMethod =
+      [aDecoder decodeObjectOfClass:[NSString class]
+                             forKey:OIDTokenEndpointAuthenticationMethodParam];
+  NSSet *additionalParameterCodingClasses = [NSSet setWithArray:@[ [NSDictionary class],
+                                                                   [NSString class] ]];
+  NSDictionary *additionalParameters =
+      [aDecoder decodeObjectOfClasses:additionalParameterCodingClasses
+                               forKey:kAdditionalParametersKey];
+  self = [self initWithConfiguration:configuration
+                        redirectURIs:redirectURIs
+                       responseTypes:responseTypes
+                          grantTypes:grantTypes
+                         subjectType:subjectType
+             tokenEndpointAuthMethod:tokenEndpointAuthenticationMethod
+                  initialAccessToken:initialAccessToken
+                additionalParameters:additionalParameters];
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_configuration forKey:kConfigurationKey];
+  [aCoder encodeObject:_initialAccessToken forKey:kInitialAccessToken];
+  [aCoder encodeObject:_redirectURIs forKey:kRedirectURIsKey];
+  [aCoder encodeObject:_responseTypes forKey:kResponseTypesKey];
+  [aCoder encodeObject:_grantTypes forKey:kGrantTypesKey];
+  [aCoder encodeObject:_subjectType forKey:kSubjectTypeKey];
+  [aCoder encodeObject:_tokenEndpointAuthenticationMethod
+                forKey:OIDTokenEndpointAuthenticationMethodParam];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  NSURLRequest *request = [self URLRequest];
+  NSString *requestBody = [[NSString alloc] initWithData:request.HTTPBody
+                                                encoding:NSUTF8StringEncoding];
+  return [NSString stringWithFormat:@"<%@: %p, request: <URL: %@, HTTPBody: %@>>",
+                                    NSStringFromClass([self class]),
+                                    (void *)self,
+                                    request.URL,
+                                    requestBody];
+}
+
+- (NSURLRequest *)URLRequest {
+  static NSString *const kHTTPPost = @"POST";
+  static NSString *const kBearer = @"Bearer";
+  static NSString *const kHTTPContentTypeHeaderKey = @"Content-Type";
+  static NSString *const kHTTPContentTypeHeaderValue = @"application/json";
+  static NSString *const kHTTPAuthorizationHeaderKey = @"Authorization";
+
+  NSData *postBody = [self JSONString];
+  if (!postBody) {
+    return nil;
+  }
+
+  NSURL *registrationRequestURL = _configuration.registrationEndpoint;
+  NSMutableURLRequest *URLRequest =
+      [[NSURLRequest requestWithURL:registrationRequestURL] mutableCopy];
+  URLRequest.HTTPMethod = kHTTPPost;
+  [URLRequest setValue:kHTTPContentTypeHeaderValue forHTTPHeaderField:kHTTPContentTypeHeaderKey];
+  if (_initialAccessToken) {
+    NSString *value = [NSString stringWithFormat:@"%@ %@", kBearer, _initialAccessToken];
+    [URLRequest setValue:value forHTTPHeaderField:kHTTPAuthorizationHeaderKey];
+  }
+  URLRequest.HTTPBody = postBody;
+  return URLRequest;
+}
+
+- (NSData *)JSONString {
+  // Dictionary with several kay/value pairs and the above array of arrays
+  NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+  NSMutableArray<NSString *> *redirectURIStrings =
+  [NSMutableArray arrayWithCapacity:[_redirectURIs count]];
+  for (id obj in _redirectURIs) {
+    [redirectURIStrings addObject:[obj absoluteString]];
+  }
+  dict[OIDRedirectURIsParam] = redirectURIStrings;
+  dict[OIDApplicationTypeParam] = _applicationType;
+
+  if (_additionalParameters) {
+    // Add any additional parameters first to allow them
+    // to be overwritten by instance values
+    [dict addEntriesFromDictionary:_additionalParameters];
+  }
+  if (_responseTypes) {
+    dict[OIDResponseTypesParam] = _responseTypes;
+  }
+  if (_grantTypes) {
+    dict[OIDGrantTypesParam] = _grantTypes;
+  }
+  if (_subjectType) {
+    dict[OIDSubjectTypeParam] = _subjectType;
+  }
+  if (_tokenEndpointAuthenticationMethod) {
+    dict[OIDTokenEndpointAuthenticationMethodParam] = _tokenEndpointAuthenticationMethod;
+  }
+
+  NSError *error;
+  NSData *json = [NSJSONSerialization dataWithJSONObject:dict options:kNilOptions error:&error];
+  if (json == nil || error != nil) {
+    return nil;
+  }
+
+  return json;
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDRegistrationResponse.h

@@ -0,0 +1,126 @@
+/*! @file OIDRegistrationResponse.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+
+#import <Foundation/Foundation.h>
+
+@class OIDRegistrationRequest;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Parameter name for the client id.
+ */
+extern NSString *const OIDClientIDParam;
+
+/*! @brief Parameter name for the client id issuance timestamp.
+ */
+extern NSString *const OIDClientIDIssuedAtParam;
+
+/*! @brief Parameter name for the client secret.
+ */
+extern NSString *const OIDClientSecretParam;
+
+/*! @brief Parameter name for the client secret expiration time.
+ */
+extern NSString *const OIDClientSecretExpirestAtParam;
+
+/*! @brief Parameter name for the registration access token.
+ */
+extern NSString *const OIDRegistrationAccessTokenParam;
+
+/*! @brief Parameter name for the client configuration URI.
+ */
+extern NSString *const OIDRegistrationClientURIParam;
+
+/*! @brief Represents a registration response.
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@interface OIDRegistrationResponse : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The request which was serviced.
+ */
+@property(nonatomic, readonly) OIDRegistrationRequest *request;
+
+/*! @brief The registered client identifier.
+    @remarks client_id
+    @see https://tools.ietf.org/html/rfc6749#section-4
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+@property(nonatomic, readonly) NSString *clientID;
+
+/*! @brief Timestamp of when the client identifier was issued, if provided.
+    @remarks client_id_issued_at
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@property(nonatomic, readonly, nullable) NSDate *clientIDIssuedAt;
+
+/*! @brief TThe client secret, which is part of the client credentials, if provided.
+    @remarks client_secret
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@property(nonatomic, readonly, nullable) NSString *clientSecret;
+
+/*! @brief Timestamp of when the client credentials expires, if provided.
+    @remarks client_secret_expires_at
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@property(nonatomic, readonly, nullable) NSDate *clientSecretExpiresAt;
+
+/*! @brief Client registration access token that can be used for subsequent operations upon the
+        client registration.
+    @remarks registration_access_token
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@property(nonatomic, readonly, nullable) NSString *registrationAccessToken;
+
+/*! @brief Location of the client configuration endpoint, if provided.
+    @remarks registration_client_uri
+    @see https://openid.net/specs/openid-connect-registration-1_0.html#RegistrationResponse
+ */
+@property(nonatomic, readonly, nullable) NSURL *registrationClientURI;
+
+/*! @brief Client authentication method to use at the token endpoint, if provided.
+    @remarks token_endpoint_auth_method
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication
+ */
+@property(nonatomic, readonly, nullable) NSString *tokenEndpointAuthenticationMethod;
+
+/*! @brief Additional parameters returned from the token server.
+ */
+@property(nonatomic, readonly, nullable) NSDictionary<NSString *, NSObject <NSCopying> *>
+    *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use initWithRequest
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Designated initializer.
+    @param request The serviced request.
+    @param parameters The decoded parameters returned from the Authorization Server.
+    @remarks Known parameters are extracted from the @c parameters parameter and the normative
+        properties are populated. Non-normative parameters are placed in the
+        @c #additionalParameters dictionary.
+ */
+- (instancetype)initWithRequest:(OIDRegistrationRequest *)request
+                     parameters:(NSDictionary<NSString *, NSObject <NSCopying> *> *)parameters
+                     NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDRegistrationResponse.m

@@ -0,0 +1,164 @@
+/*! @file OIDRegistrationResponse.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2016 The AppAuth for iOS Authors. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDRegistrationResponse.h"
+
+#import "OIDClientMetadataParameters.h"
+#import "OIDDefines.h"
+#import "OIDFieldMapping.h"
+#import "OIDRegistrationRequest.h"
+#import "OIDTokenUtilities.h"
+
+NSString *const OIDClientIDParam = @"client_id";
+NSString *const OIDClientIDIssuedAtParam = @"client_id_issued_at";
+NSString *const OIDClientSecretParam = @"client_secret";
+NSString *const OIDClientSecretExpirestAtParam = @"client_secret_expires_at";
+NSString *const OIDRegistrationAccessTokenParam = @"registration_access_token";
+NSString *const OIDRegistrationClientURIParam = @"registration_client_uri";
+
+/*! @brief Key used to encode the @c request property for @c NSSecureCoding
+ */
+static NSString *const kRequestKey = @"request";
+
+/*! @brief Key used to encode the @c additionalParameters property for @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+@implementation OIDRegistrationResponse
+
+/*! @brief Returns a mapping of incoming parameters to instance variables.
+    @return A mapping of incoming parameters to instance variables.
+ */
++ (NSDictionary<NSString *, OIDFieldMapping *> *)fieldMap {
+  static NSMutableDictionary<NSString *, OIDFieldMapping *> *fieldMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    fieldMap = [NSMutableDictionary dictionary];
+    fieldMap[OIDClientIDParam] = [[OIDFieldMapping alloc] initWithName:@"_clientID"
+                                                                  type:[NSString class]];
+    fieldMap[OIDClientIDIssuedAtParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_clientIDIssuedAt"
+                                     type:[NSDate class]
+                               conversion:[OIDFieldMapping dateEpochConversion]];
+    fieldMap[OIDClientSecretParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_clientSecret"
+                                     type:[NSString class]];
+    fieldMap[OIDClientSecretExpirestAtParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_clientSecretExpiresAt"
+                                     type:[NSDate class]
+                               conversion:[OIDFieldMapping dateEpochConversion]];
+    fieldMap[OIDRegistrationAccessTokenParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_registrationAccessToken"
+                                     type:[NSString class]];
+    fieldMap[OIDRegistrationClientURIParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_registrationClientURI"
+                                     type:[NSURL class]
+                               conversion:[OIDFieldMapping URLConversion]];
+    fieldMap[OIDTokenEndpointAuthenticationMethodParam] =
+    [[OIDFieldMapping alloc] initWithName:@"_tokenEndpointAuthenticationMethod"
+                                     type:[NSString class]];
+  });
+  return fieldMap;
+}
+
+
+#pragma mark - Initializers
+
+- (nonnull instancetype)init
+  OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithRequest:parameters:))
+
+- (instancetype)initWithRequest:(OIDRegistrationRequest *)request
+                              parameters:(NSDictionary<NSString *, NSObject <NSCopying> *> *)parameters {
+  self = [super init];
+  if (self) {
+    _request = [request copy];
+    NSDictionary<NSString *, NSObject <NSCopying> *> *additionalParameters =
+    [OIDFieldMapping remainingParametersWithMap:[[self class] fieldMap]
+                                     parameters:parameters
+                                       instance:self];
+    _additionalParameters = additionalParameters;
+
+    if ((_clientSecret && !_clientSecretExpiresAt)
+        || (!!_registrationClientURI != !!_registrationAccessToken)) {
+      // If client_secret is issued, client_secret_expires_at is REQUIRED,
+      // and the response MUST contain "[...] both a Client Configuration Endpoint
+      // and a Registration Access Token or neither of them"
+      return nil;
+    }
+  }
+  return self;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDRegistrationRequest *request = [aDecoder decodeObjectOfClass:[OIDRegistrationRequest class]
+                                                           forKey:kRequestKey];
+  self = [self initWithRequest:request
+                    parameters:@{}];
+  if (self) {
+    [OIDFieldMapping decodeWithCoder:aDecoder
+                                 map:[[self class] fieldMap]
+                            instance:self];
+    _additionalParameters = [aDecoder decodeObjectOfClasses:[OIDFieldMapping JSONTypes]
+                                                     forKey:kAdditionalParametersKey];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [OIDFieldMapping encodeWithCoder:aCoder map:[[self class] fieldMap] instance:self];
+  [aCoder encodeObject:_request forKey:kRequestKey];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p, clientID: \"%@\", clientIDIssuedAt: %@, "
+          "clientSecret: %@, clientSecretExpiresAt: \"%@\", "
+          "registrationAccessToken: \"%@\", "
+          "registrationClientURI: \"%@\", "
+          "additionalParameters: %@, request: %@>",
+          NSStringFromClass([self class]),
+          (void *)self,
+          _clientID,
+          _clientIDIssuedAt,
+          [OIDTokenUtilities redact:_clientSecret],
+          _clientSecretExpiresAt,
+          [OIDTokenUtilities redact:_registrationAccessToken],
+          _registrationClientURI,
+          _additionalParameters,
+          _request];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDResponseTypes.h

@@ -0,0 +1,31 @@
+/*! @file OIDResponseTypes.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*! @brief A constant for the standard OAuth2 Response Type of 'code'.
+ */
+extern NSString *const OIDResponseTypeCode;
+
+/*! @brief A constant for the standard OAuth2 Response Type of 'token'.
+ */
+extern NSString *const OIDResponseTypeToken;
+
+/*! @brief A constant for the standard OAuth2 Response Type of 'id_token'.
+ */
+extern NSString *const OIDResponseTypeIDToken;

Pods/AppAuth/Source/AppAuthCore/OIDResponseTypes.m

@@ -0,0 +1,25 @@
+/*! @file OIDResponseTypes.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDResponseTypes.h"
+
+NSString *const OIDResponseTypeCode = @"code";
+
+NSString *const OIDResponseTypeToken = @"token";
+
+NSString *const OIDResponseTypeIDToken = @"id_token";

Pods/AppAuth/Source/AppAuthCore/OIDScopeUtilities.h

@@ -0,0 +1,48 @@
+/*! @file OIDScopeUtilities.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Provides convenience methods for dealing with scope strings.
+ */
+@interface OIDScopeUtilities : NSObject
+
+/*! @internal
+    @brief Unavailable. This class should not be initialized.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Converts an array of scope strings to a single scope string per the OAuth 2 spec.
+    @param scopes An array of scope strings.
+    @return A space-delimited string of scopes.
+    @see https://tools.ietf.org/html/rfc6749#section-3.3
+ */
++ (NSString *)scopesWithArray:(NSArray<NSString *> *)scopes;
+
+/*! @brief Converts an OAuth 2 spec-compliant scope string to an array of scopes.
+    @param scopes An OAuth 2 spec-compliant scope string.
+    @return An array of scope strings.
+    @see https://tools.ietf.org/html/rfc6749#section-3.3
+ */
++ (NSArray<NSString *> *)scopesArrayWithString:(NSString *)scopes;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDScopeUtilities.m

@@ -0,0 +1,58 @@
+/*! @file OIDScopeUtilities.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDScopeUtilities.h"
+
+@implementation OIDScopeUtilities
+
+/*! @brief A character set with the characters NOT allowed in a scope name.
+    @see https://tools.ietf.org/html/rfc6749#section-3.3
+ */
++ (NSCharacterSet *)disallowedScopeCharacters {
+  static NSCharacterSet *disallowedCharacters;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableCharacterSet *allowedCharacters;
+    allowedCharacters =
+        [NSMutableCharacterSet characterSetWithRange:NSMakeRange(0x23, 0x5B - 0x23 + 1)];
+    [allowedCharacters addCharactersInRange:NSMakeRange(0x5D, 0x7E - 0x5D + 1)];
+    [allowedCharacters addCharactersInString:@"\x21"];
+    disallowedCharacters = [allowedCharacters invertedSet];
+  });
+  return disallowedCharacters;
+}
+
++ (NSString *)scopesWithArray:(NSArray<NSString *> *)scopes {
+#if !defined(NS_BLOCK_ASSERTIONS)
+  NSCharacterSet *disallowedCharacters = [self disallowedScopeCharacters];
+  for (NSString *scope in scopes) {
+    NSAssert(scope.length, @"Found illegal empty scope string.");
+    NSAssert([scope rangeOfCharacterFromSet:disallowedCharacters].location == NSNotFound,
+             @"Found illegal character in scope string.");
+  }
+#endif // !defined(NS_BLOCK_ASSERTIONS)
+
+  NSString *scopeString = [scopes componentsJoinedByString:@" "];
+  return scopeString;
+}
+
++ (NSArray<NSString *> *)scopesArrayWithString:(NSString *)scopes {
+  return [scopes componentsSeparatedByString:@" "];
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDScopes.h

@@ -0,0 +1,46 @@
+/*! @file OIDScopes.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*! @brief Scope that indicates this request is an OpenID Connect request.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#AuthRequestValidation
+ */
+extern NSString *const OIDScopeOpenID;
+
+/*! @brief This scope value requests access to the End-User's default profile Claims, which are:
+        name, family_name, given_name, middle_name, nickname, preferred_username, profile, picture,
+        website, gender, birthdate, zoneinfo, locale, and updated_at.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims
+ */
+extern NSString *const OIDScopeProfile;
+
+/*! @brief This scope value requests access to the email and email_verified Claims.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims
+ */
+extern NSString *const OIDScopeEmail;
+
+/*! @brief This scope value requests access to the address Claim.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims
+ */
+extern NSString *const OIDScopeAddress;
+
+/*! @brief This scope value requests access to the phone_number and phone_number_verified Claims.
+    @see http://openid.net/specs/openid-connect-core-1_0.html#ScopeClaims
+ */
+extern NSString *const OIDScopePhone;

Pods/AppAuth/Source/AppAuthCore/OIDScopes.m

@@ -0,0 +1,29 @@
+/*! @file OIDScopes.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDScopes.h"
+
+NSString *const OIDScopeOpenID = @"openid";
+
+NSString *const OIDScopeProfile = @"profile";
+
+NSString *const OIDScopeEmail = @"email";
+
+NSString *const OIDScopeAddress = @"address";
+
+NSString *const OIDScopePhone = @"phone";

Pods/AppAuth/Source/AppAuthCore/OIDServiceConfiguration.h

@@ -0,0 +1,118 @@
+/*! @file OIDServiceConfiguration.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDServiceConfiguration;
+@class OIDServiceDiscovery;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief The type of block called when a @c OIDServiceConfiguration has been created
+        by loading a @c OIDServiceDiscovery from an @c NSURL.
+ */
+typedef void (^OIDServiceConfigurationCreated)
+    (OIDServiceConfiguration *_Nullable serviceConfiguration,
+     NSError *_Nullable error);
+
+/*! @brief Represents the information needed to construct a @c OIDAuthorizationService.
+ */
+@interface OIDServiceConfiguration : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The authorization endpoint URI.
+ */
+@property(nonatomic, readonly) NSURL *authorizationEndpoint;
+
+/*! @brief The token exchange and refresh endpoint URI.
+ */
+@property(nonatomic, readonly) NSURL *tokenEndpoint;
+
+/*! @brief The OpenID Connect issuer.
+ */
+@property(nonatomic, readonly, nullable) NSURL *issuer;
+
+/*! @brief The dynamic client registration endpoint URI.
+ */
+@property(nonatomic, readonly, nullable) NSURL *registrationEndpoint;
+
+/*! @brief The end session logout endpoint URI.
+ */
+@property(nonatomic, readonly, nullable) NSURL *endSessionEndpoint;
+
+/*! @brief The discovery document.
+ */
+@property(nonatomic, readonly, nullable) OIDServiceDiscovery *discoveryDocument;
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithAuthorizationEndpoint:tokenEndpoint: or
+        @c initWithDiscoveryDocument:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @param authorizationEndpoint The authorization endpoint URI.
+    @param tokenEndpoint The token exchange and refresh endpoint URI.
+ */
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint;
+
+/*! @param authorizationEndpoint The authorization endpoint URI.
+    @param tokenEndpoint The token exchange and refresh endpoint URI.
+    @param registrationEndpoint The dynamic client registration endpoint URI.
+ */
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint;
+
+/*! @param authorizationEndpoint The authorization endpoint URI.
+    @param tokenEndpoint The token exchange and refresh endpoint URI.
+    @param issuer The OpenID Connect issuer.
+ */
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer;
+
+/*! @param authorizationEndpoint The authorization endpoint URI.
+    @param tokenEndpoint The token exchange and refresh endpoint URI.
+    @param issuer The OpenID Connect issuer.
+    @param registrationEndpoint The dynamic client registration endpoint URI.
+ */
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint;
+
+/*! @param authorizationEndpoint The authorization endpoint URI.
+    @param tokenEndpoint The token exchange and refresh endpoint URI.
+    @param issuer The OpenID Connect issuer.
+    @param registrationEndpoint The dynamic client registration endpoint URI.
+    @param endSessionEndpoint The end session endpoint (logout) URI.
+ */
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint
+                           endSessionEndpoint:(nullable NSURL *)endSessionEndpoint;
+
+/*! @param discoveryDocument The discovery document from which to extract the required OAuth
+        configuration.
+ */
+- (instancetype)initWithDiscoveryDocument:(OIDServiceDiscovery *)discoveryDocument;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDServiceConfiguration.m

@@ -0,0 +1,223 @@
+/*! @file OIDServiceConfiguration.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDServiceConfiguration.h"
+
+#import "OIDDefines.h"
+#import "OIDErrorUtilities.h"
+#import "OIDServiceDiscovery.h"
+
+/*! @brief The key for the @c authorizationEndpoint property.
+ */
+static NSString *const kAuthorizationEndpointKey = @"authorizationEndpoint";
+
+/*! @brief The key for the @c tokenEndpoint property.
+ */
+static NSString *const kTokenEndpointKey = @"tokenEndpoint";
+
+/*! @brief The key for the @c issuer property.
+ */
+static NSString *const kIssuerKey = @"issuer";
+
+/*! @brief The key for the @c registrationEndpoint property.
+ */
+static NSString *const kRegistrationEndpointKey = @"registrationEndpoint";
+
+/*! @brief The key for the @c endSessionEndpoint property.
+ */
+static NSString *const kEndSessionEndpointKey = @"endSessionEndpoint";
+
+/*! @brief The key for the @c discoveryDocument property.
+ */
+static NSString *const kDiscoveryDocumentKey = @"discoveryDocument";
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OIDServiceConfiguration ()
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint
+                           endSessionEndpoint:(nullable NSURL *)endSessionEndpoint
+                            discoveryDocument:(nullable OIDServiceDiscovery *)discoveryDocument
+                            NS_DESIGNATED_INITIALIZER;
+
+@end
+
+@implementation OIDServiceConfiguration
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(@selector(
+        initWithAuthorizationEndpoint:
+                        tokenEndpoint:)
+    )
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+        tokenEndpoint:(NSURL *)tokenEndpoint
+               issuer:(nullable NSURL *)issuer
+ registrationEndpoint:(nullable NSURL *)registrationEndpoint
+   endSessionEndpoint:(nullable OIDServiceDiscovery *)endSessionEndpoint
+    discoveryDocument:(nullable OIDServiceDiscovery *)discoveryDocument {
+
+  self = [super init];
+  if (self) {
+    _authorizationEndpoint = [authorizationEndpoint copy];
+    _tokenEndpoint = [tokenEndpoint copy];
+    _issuer = [issuer copy];
+    _registrationEndpoint = [registrationEndpoint copy];
+    _endSessionEndpoint = [endSessionEndpoint copy];
+    _discoveryDocument = [discoveryDocument copy];
+  }
+  return self;
+}
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint {
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:nil
+                        registrationEndpoint:nil
+                          endSessionEndpoint:nil
+                           discoveryDocument:nil];
+}
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint {
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:nil
+                        registrationEndpoint:registrationEndpoint
+                          endSessionEndpoint:nil
+                           discoveryDocument:nil];
+}
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer {
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:issuer
+                        registrationEndpoint:nil
+                          endSessionEndpoint:nil
+                           discoveryDocument:nil];
+}
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint {
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:issuer
+                        registrationEndpoint:registrationEndpoint
+                          endSessionEndpoint:nil
+                           discoveryDocument:nil];
+}
+
+- (instancetype)initWithAuthorizationEndpoint:(NSURL *)authorizationEndpoint
+                                tokenEndpoint:(NSURL *)tokenEndpoint
+                                       issuer:(nullable NSURL *)issuer
+                         registrationEndpoint:(nullable NSURL *)registrationEndpoint
+                           endSessionEndpoint:(nullable NSURL *)endSessionEndpoint {
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:issuer
+                        registrationEndpoint:registrationEndpoint
+                          endSessionEndpoint:endSessionEndpoint
+                           discoveryDocument:nil];
+}
+
+- (instancetype)initWithDiscoveryDocument:(OIDServiceDiscovery *) discoveryDocument {
+  return [self initWithAuthorizationEndpoint:discoveryDocument.authorizationEndpoint
+                               tokenEndpoint:discoveryDocument.tokenEndpoint
+                                      issuer:discoveryDocument.issuer
+                        registrationEndpoint:discoveryDocument.registrationEndpoint
+                          endSessionEndpoint:discoveryDocument.endSessionEndpoint
+                           discoveryDocument:discoveryDocument];
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder {
+  NSURL *authorizationEndpoint = [aDecoder decodeObjectOfClass:[NSURL class]
+                                                        forKey:kAuthorizationEndpointKey];
+  NSURL *tokenEndpoint = [aDecoder decodeObjectOfClass:[NSURL class]
+                                                forKey:kTokenEndpointKey];
+  NSURL *issuer = [aDecoder decodeObjectOfClass:[NSURL class]
+                                         forKey:kIssuerKey];
+  NSURL *registrationEndpoint = [aDecoder decodeObjectOfClass:[NSURL class]
+                                                       forKey:kRegistrationEndpointKey];
+  NSURL *endSessionEndpoint = [aDecoder decodeObjectOfClass:[NSURL class]
+                                                       forKey:kEndSessionEndpointKey];
+  // We don't accept nil authorizationEndpoints or tokenEndpoints.
+  if (!authorizationEndpoint || !tokenEndpoint) {
+    return nil;
+  }
+
+  OIDServiceDiscovery *discoveryDocument = [aDecoder decodeObjectOfClass:[OIDServiceDiscovery class]
+                                                                  forKey:kDiscoveryDocumentKey];
+
+  return [self initWithAuthorizationEndpoint:authorizationEndpoint
+                               tokenEndpoint:tokenEndpoint
+                                      issuer:issuer
+                        registrationEndpoint:registrationEndpoint
+                          endSessionEndpoint:endSessionEndpoint
+                           discoveryDocument:discoveryDocument];
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_authorizationEndpoint forKey:kAuthorizationEndpointKey];
+  [aCoder encodeObject:_tokenEndpoint forKey:kTokenEndpointKey];
+  [aCoder encodeObject:_issuer forKey:kIssuerKey];
+  [aCoder encodeObject:_registrationEndpoint forKey:kRegistrationEndpointKey];
+  [aCoder encodeObject:_discoveryDocument forKey:kDiscoveryDocumentKey];
+  [aCoder encodeObject:_endSessionEndpoint forKey:kEndSessionEndpointKey];
+}
+
+#pragma mark - description
+
+- (NSString *)description {
+  return [NSString stringWithFormat:
+      @"OIDServiceConfiguration authorizationEndpoint: %@, tokenEndpoint: %@, "
+          "registrationEndpoint: %@, endSessionEndpoint: %@, discoveryDocument: [%@]",
+      _authorizationEndpoint,
+      _tokenEndpoint,
+      _registrationEndpoint,
+      _endSessionEndpoint,
+      _discoveryDocument];
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDServiceDiscovery.h

@@ -0,0 +1,358 @@
+/*! @file OIDServiceDiscovery.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents an OpenID Connect 1.0 Discovery Document
+    @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata
+ */
+@interface OIDServiceDiscovery : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The decoded OpenID Connect 1.0 Discovery Document as a dictionary.
+ */
+@property(nonatomic, readonly) NSDictionary<NSString *, id> *discoveryDictionary;
+
+/*! @brief REQUIRED. URL using the @c https scheme with no query or fragment component that the OP
+        asserts as its Issuer Identifier. If Issuer discovery is supported, this value MUST be
+        identical to the issuer value returned by WebFinger. This also MUST be identical to the
+        @c iss Claim value in ID Tokens issued from this Issuer.
+    @remarks issuer
+    @seealso https://openid.net/specs/openid-connect-discovery-1_0.html#IssuerDiscovery
+ */
+@property(nonatomic, readonly) NSURL *issuer;
+
+/*! @brief REQUIRED. URL of the OP's OAuth 2.0 Authorization Endpoint.
+    @remarks authorization_endpoint
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint
+ */
+@property(nonatomic, readonly) NSURL *authorizationEndpoint;
+
+/*! @brief URL of the OP's OAuth 2.0 Token Endpoint. This is REQUIRED unless only the Implicit Flow
+        is used.
+    @remarks token_endpoint
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint
+ */
+@property(nonatomic, readonly) NSURL *tokenEndpoint;
+
+/*! @brief RECOMMENDED. URL of the OP's UserInfo Endpoint. This URL MUST use the https scheme and
+        MAY contain port, path, and query parameter components.
+    @remarks userinfo_endpoint
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html#UserInfo
+ */
+@property(nonatomic, readonly, nullable) NSURL *userinfoEndpoint;
+
+/*! @brief REQUIRED. URL of the OP's JSON Web Key Set document. This contains the signing key(s) the
+        RP uses to validate signatures from the OP. The JWK Set MAY also contain the Server's
+        encryption key(s), which are used by RPs to encrypt requests to the Server. When both
+        signing and encryption keys are made available, a use (Key Use) parameter value is REQUIRED
+        for all keys in the referenced JWK Set to indicate each key's intended usage. Although some
+        algorithms allow the same key to be used for both signatures and encryption, doing so is NOT
+        RECOMMENDED, as it is less secure. The JWK x5c parameter MAY be used to provide X.509
+        representations of keys provided. When used, the bare key values MUST still be present and
+        MUST match those in the certificate.
+    @remarks jwks_uri
+    @seealso http://tools.ietf.org/html/rfc7517
+ */
+@property(nonatomic, readonly) NSURL *jwksURL;
+
+/*! @brief RECOMMENDED. URL of the OP's Dynamic Client Registration Endpoint.
+    @remarks registration_endpoint
+    @seealso http://openid.net/specs/openid-connect-registration-1_0.html
+ */
+@property(nonatomic, readonly, nullable) NSURL *registrationEndpoint;
+
+/* @brief OPTIONAL. URL of the OP's RP-Initiated Logout endpoint.
+   @remarks end_session_endpoint
+   @seealso http://openid.net/specs/openid-connect-session-1_0.html#OPMetadata
+ */
+@property(nonatomic, readonly, nullable) NSURL *endSessionEndpoint;
+
+/*! @brief RECOMMENDED. JSON array containing a list of the OAuth 2.0 [RFC6749] scope values that
+        this server supports. The server MUST support the openid scope value. Servers MAY choose not
+        to advertise some supported scope values even when this parameter is used, although those
+        defined in [OpenID.Core] SHOULD be listed, if supported.
+    @remarks scopes_supported
+    @seealso http://tools.ietf.org/html/rfc6749#section-3.3
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *scopesSupported;
+
+/*! @brief REQUIRED. JSON array containing a list of the OAuth 2.0 @c response_type values that this
+        OP supports. Dynamic OpenID Providers MUST support the @c code, @c id_token, and the token
+        @c id_token Response Type values.
+    @remarks response_types_supported
+ */
+@property(nonatomic, readonly) NSArray<NSString *> *responseTypesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the OAuth 2.0 @c response_mode values that this
+        OP supports, as specified in OAuth 2.0 Multiple Response Type Encoding Practices. If
+        omitted, the default for Dynamic OpenID Providers is @c ["query", "fragment"].
+    @remarks response_modes_supported
+    @seealso http://openid.net/specs/oauth-v2-multiple-response-types-1_0.html
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *responseModesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the OAuth 2.0 Grant Type values that this OP
+        supports. Dynamic OpenID Providers MUST support the @c authorization_code and @c implicit
+        Grant Type values and MAY support other Grant Types. If omitted, the default value is
+        @c ["authorization_code", "implicit"].
+    @remarks grant_types_supported
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *grantTypesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the Authentication Context Class References
+        that this OP supports.
+    @remarks acr_values_supported
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *acrValuesSupported;
+
+/*! @brief REQUIRED. JSON array containing a list of the Subject Identifier types that this OP
+        supports. Valid types include @c pairwise and @c public.
+    @remarks subject_types_supported
+ */
+@property(nonatomic, readonly) NSArray<NSString *> *subjectTypesSupported;
+
+/*! @brief REQUIRED. JSON array containing a list of the JWS signing algorithms (@c alg values)
+        supported by the OP for the ID Token to encode the Claims in a JWT. The algorithm @c RS256
+        MUST be included. The value @c none MAY be supported, but MUST NOT be used unless the
+        Response Type used returns no ID Token from the Authorization Endpoint (such as when using
+        the Authorization Code Flow).
+    @remarks id_token_signing_alg_values_supported
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly) NSArray<NSString *> *IDTokenSigningAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (@c alg values)
+        supported by the OP for the ID Token to encode the Claims in a JWT.
+    @remarks id_token_encryption_alg_values_supported
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *IDTokenEncryptionAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (@c enc values)
+        supported by the OP for the ID Token to encode the Claims in a JWT.
+    @remarks id_token_encryption_enc_values_supported
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *IDTokenEncryptionEncodingValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWS signing algorithms (@c alg values)
+        supported by the UserInfo Endpoint to encode the Claims in a JWT. The value none MAY be
+        included.
+    @remarks userinfo_signing_alg_values_supported
+    @seealso https://tools.ietf.org/html/rfc7515
+    @seealso https://tools.ietf.org/html/rfc7518
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *userinfoSigningAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (alg values)
+        supported by the UserInfo Endpoint to encode the Claims in a JWT.
+    @remarks userinfo_encryption_alg_values_supported
+    @seealso https://tools.ietf.org/html/rfc7516
+    @seealso https://tools.ietf.org/html/rfc7518
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *userinfoEncryptionAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (@c enc values)
+        supported by the UserInfo Endpoint to encode the Claims in a JWT.
+    @remarks userinfo_encryption_enc_values_supported
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *userinfoEncryptionEncodingValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWS signing algorithms (@c alg values)
+        supported by the OP for Request Objects, which are described in Section 6.1 of OpenID
+        Connect Core 1.0. These algorithms are used both when the Request Object is passed by value
+        (using the request parameter) and when it is passed by reference (using the @c request_uri
+        parameter). Servers SHOULD support @c none and @c RS256.
+    @remarks request_object_signing_alg_values_supported
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *requestObjectSigningAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (@c alg values)
+        supported by the OP for Request Objects. These algorithms are used both when the Request
+        Object is passed by value and when it is passed by reference.
+    @remarks request_object_encryption_alg_values_supported
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *requestObjectEncryptionAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWE encryption algorithms (@c enc values)
+        supported by the OP for Request Objects. These algorithms are used both when the Request
+        Object is passed by value and when it is passed by reference.
+    @remarks request_object_encryption_enc_values_supported
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *requestObjectEncryptionEncodingValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of Client Authentication methods supported by this
+        Token Endpoint. The options are @c client_secret_post, @c client_secret_basic,
+        @c client_secret_jwt, and @c private_key_jwt, as described in Section 9 of OpenID Connect
+        Core 1.0. Other authentication methods MAY be defined by extensions. If omitted, the default
+        is @c client_secret_basic -- the HTTP Basic Authentication Scheme specified in Section 2.3.1
+        of OAuth 2.0.
+    @remarks token_endpoint_auth_methods_supported
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html
+    @seealso http://tools.ietf.org/html/rfc6749#section-2.3.1
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *tokenEndpointAuthMethodsSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the JWS signing algorithms (@c alg values)
+        supported by the Token Endpoint for the signature on the JWT used to authenticate the Client
+        at the Token Endpoint for the @c private_key_jwt and @c client_secret_jwt authentication
+        methods. Servers SHOULD support @c RS256. The value @c none MUST NOT be used.
+    @remarks token_endpoint_auth_signing_alg_values_supported
+    @seealso https://tools.ietf.org/html/rfc7519
+ */
+@property(nonatomic, readonly, nullable)
+    NSArray<NSString *> *tokenEndpointAuthSigningAlgorithmValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the @c display parameter values that the OpenID
+        Provider supports. These values are described in Section 3.1.2.1 of OpenID Connect Core 1.0.
+    @remarks display_values_supported
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *displayValuesSupported;
+
+/*! @brief OPTIONAL. JSON array containing a list of the Claim Types that the OpenID Provider
+        supports. These Claim Types are described in Section 5.6 of OpenID Connect Core 1.0. Values
+        defined by this specification are @c normal, @c aggregated, and @c distributed. If omitted,
+        the implementation supports only @c normal Claims.
+    @remarks claim_types_supported
+    @seealso http://openid.net/specs/openid-connect-core-1_0.html
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *claimTypesSupported;
+
+/*! @brief RECOMMENDED. JSON array containing a list of the Claim Names of the Claims that the
+        OpenID Provider MAY be able to supply values for. Note that for privacy or other reasons,
+        this might not be an exhaustive list.
+    @remarks claims_supported
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *claimsSupported;
+
+/*! @brief OPTIONAL. URL of a page containing human-readable information that developers might want
+        or need to know when using the OpenID Provider. In particular, if the OpenID Provider does
+        not support Dynamic Client Registration, then information on how to register Clients needs
+        to be provided in this documentation.
+    @remarks service_documentation
+ */
+@property(nonatomic, readonly, nullable) NSURL *serviceDocumentation;
+
+/*! @brief OPTIONAL. Languages and scripts supported for values in Claims being returned,
+        represented as a JSON array of BCP47 language tag values. Not all languages and scripts are
+        necessarily supported for all Claim values.
+    @remarks claims_locales_supported
+    @seealso http://tools.ietf.org/html/rfc5646
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *claimsLocalesSupported;
+
+/*! @brief OPTIONAL. Languages and scripts supported for the user interface, represented as a JSON
+        array of BCP47 language tag values.
+    @remarks ui_locales_supported
+    @seealso http://tools.ietf.org/html/rfc5646
+ */
+@property(nonatomic, readonly, nullable) NSArray<NSString *> *UILocalesSupported;
+
+/*! @brief OPTIONAL. Boolean value specifying whether the OP supports use of the claims parameter,
+        with @c true indicating support. If omitted, the default value is @c false.
+    @remarks claims_parameter_supported
+ */
+@property(nonatomic, readonly) BOOL claimsParameterSupported;
+
+/*! @brief OPTIONAL. Boolean value specifying whether the OP supports use of the request parameter,
+        with @c true indicating support. If omitted, the default value is @c false.
+    @remarks request_parameter_supported
+ */
+@property(nonatomic, readonly) BOOL requestParameterSupported;
+
+/*! @brief OPTIONAL. Boolean value specifying whether the OP supports use of the @c request_uri
+        parameter, with true indicating support. If omitted, the default value is @c true.
+    @remarks request_uri_parameter_supported
+ */
+@property(nonatomic, readonly) BOOL requestURIParameterSupported;
+
+/*! @brief OPTIONAL. Boolean value specifying whether the OP requires any @c request_uri values used
+        to be pre-registered using the @c request_uris registration parameter. Pre-registration is
+        REQUIRED when the value is @c true. If omitted, the default value is @c false.
+    @remarks require_request_uri_registration
+ */
+@property(nonatomic, readonly) BOOL requireRequestURIRegistration;
+
+/*! @brief OPTIONAL. URL that the OpenID Provider provides to the person registering the Client to
+        read about the OP's requirements on how the Relying Party can use the data provided by the
+        OP. The registration process SHOULD display this URL to the person registering the Client if
+        it is given.
+    @remarks op_policy_uri
+ */
+@property(nonatomic, readonly, nullable) NSURL *OPPolicyURI;
+
+/*! @brief OPTIONAL. URL that the OpenID Provider provides to the person registering the Client to
+        read about OpenID Provider's terms of service. The registration process SHOULD display this
+        URL to the person registering the Client if it is given.
+    @remarks op_tos_uri
+ */
+@property(nonatomic, readonly, nullable) NSURL *OPTosURI;
+
+/*! @internal
+    @brief Unavailable. Please use @c initWithDictionary:error:, @c initWithJSON:error, or the
+        @c serviceDiscoveryWithURL:callback: factory method.
+ */
+- (nonnull instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Decodes a OpenID Connect Discovery 1.0 JSON document.
+    @param serviceDiscoveryJSON An OpenID Connect Service Discovery document.
+    @param error If a required field is missing from the dictionary, an error with domain
+        @c ::OIDGeneralErrorDomain and code @c ::OIDErrorCodeInvalidDiscoveryDocument will be
+        returned.
+ */
+- (nullable instancetype)initWithJSON:(NSString *)serviceDiscoveryJSON
+                                error:(NSError **_Nullable)error;
+
+/*! @brief Decodes a OpenID Connect Discovery 1.0 JSON document.
+    @param serviceDiscoveryJSONData An OpenID Connect Service Discovery document.
+    @param error If a required field is missing from the dictionary, an error with domain
+        @c ::OIDGeneralErrorDomain and code @c ::OIDErrorCodeInvalidDiscoveryDocument will be
+        returned.
+ */
+- (nullable instancetype)initWithJSONData:(NSData *)serviceDiscoveryJSONData
+                                    error:(NSError **_Nullable)error;
+
+/*! @brief Designated initializer. The dictionary keys should match the keys defined in the OpenID
+        Connect Discovery 1.0 standard for OpenID Provider Metadata.
+    @param serviceDiscoveryDictionary A dictionary representing an OpenID Connect Service Discovery
+        document.
+    @param error If a required field is missing from the dictionary, an error with domain
+        @c ::OIDGeneralErrorDomain and code @c ::OIDErrorCodeInvalidDiscoveryDocument will be
+        returned.
+ */
+- (nullable instancetype)initWithDictionary:(NSDictionary *)serviceDiscoveryDictionary
+                                      error:(NSError **_Nullable)error NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDServiceDiscovery.m

@@ -0,0 +1,362 @@
+/*! @file OIDServiceDiscovery.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDServiceDiscovery.h"
+
+#import "OIDDefines.h"
+#import "OIDErrorUtilities.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! Field keys associated with an OpenID Connect Discovery Document. */
+static NSString *const kIssuerKey = @"issuer";
+static NSString *const kAuthorizationEndpointKey = @"authorization_endpoint";
+static NSString *const kTokenEndpointKey = @"token_endpoint";
+static NSString *const kUserinfoEndpointKey = @"userinfo_endpoint";
+static NSString *const kJWKSURLKey = @"jwks_uri";
+static NSString *const kRegistrationEndpointKey = @"registration_endpoint";
+static NSString *const kEndSessionEndpointKey = @"end_session_endpoint";
+static NSString *const kScopesSupportedKey = @"scopes_supported";
+static NSString *const kResponseTypesSupportedKey = @"response_types_supported";
+static NSString *const kResponseModesSupportedKey = @"response_modes_supported";
+static NSString *const kGrantTypesSupportedKey = @"grant_types_supported";
+static NSString *const kACRValuesSupportedKey = @"acr_values_supported";
+static NSString *const kSubjectTypesSupportedKey = @"subject_types_supported";
+static NSString *const kIDTokenSigningAlgorithmValuesSupportedKey =
+    @"id_token_signing_alg_values_supported";
+static NSString *const kIDTokenEncryptionAlgorithmValuesSupportedKey =
+    @"id_token_encryption_alg_values_supported";
+static NSString *const kIDTokenEncryptionEncodingValuesSupportedKey =
+    @"id_token_encryption_enc_values_supported";
+static NSString *const kUserinfoSigningAlgorithmValuesSupportedKey =
+    @"userinfo_signing_alg_values_supported";
+static NSString *const kUserinfoEncryptionAlgorithmValuesSupportedKey =
+    @"userinfo_encryption_alg_values_supported";
+static NSString *const kUserinfoEncryptionEncodingValuesSupportedKey =
+    @"userinfo_encryption_enc_values_supported";
+static NSString *const kRequestObjectSigningAlgorithmValuesSupportedKey =
+    @"request_object_signing_alg_values_supported";
+static NSString *const kRequestObjectEncryptionAlgorithmValuesSupportedKey =
+    @"request_object_encryption_alg_values_supported";
+static NSString *const kRequestObjectEncryptionEncodingValuesSupported =
+    @"request_object_encryption_enc_values_supported";
+static NSString *const kTokenEndpointAuthMethodsSupportedKey =
+    @"token_endpoint_auth_methods_supported";
+static NSString *const kTokenEndpointAuthSigningAlgorithmValuesSupportedKey =
+    @"token_endpoint_auth_signing_alg_values_supported";
+static NSString *const kDisplayValuesSupportedKey = @"display_values_supported";
+static NSString *const kClaimTypesSupportedKey = @"claim_types_supported";
+static NSString *const kClaimsSupportedKey = @"claims_supported";
+static NSString *const kServiceDocumentationKey = @"service_documentation";
+static NSString *const kClaimsLocalesSupportedKey = @"claims_locales_supported";
+static NSString *const kUILocalesSupportedKey = @"ui_locales_supported";
+static NSString *const kClaimsParameterSupportedKey = @"claims_parameter_supported";
+static NSString *const kRequestParameterSupportedKey = @"request_parameter_supported";
+static NSString *const kRequestURIParameterSupportedKey = @"request_uri_parameter_supported";
+static NSString *const kRequireRequestURIRegistrationKey = @"require_request_uri_registration";
+static NSString *const kOPPolicyURIKey = @"op_policy_uri";
+static NSString *const kOPTosURIKey = @"op_tos_uri";
+
+@implementation OIDServiceDiscovery {
+  NSDictionary *_discoveryDictionary;
+}
+
+- (nonnull instancetype)init OID_UNAVAILABLE_USE_INITIALIZER(@selector(initWithDictionary:error:))
+
+- (nullable instancetype)initWithJSON:(NSString *)serviceDiscoveryJSON error:(NSError **)error {
+  NSData *jsonData = [serviceDiscoveryJSON dataUsingEncoding:NSUTF8StringEncoding];
+  return [self initWithJSONData:jsonData error:error];
+}
+
+- (nullable instancetype)initWithJSONData:(NSData *)serviceDiscoveryJSONData
+                                    error:(NSError **_Nullable)error {
+  NSError *jsonError;
+  NSDictionary *json =
+      [NSJSONSerialization JSONObjectWithData:serviceDiscoveryJSONData options:0 error:&jsonError];
+  if (!json || jsonError) {
+    *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeJSONDeserializationError
+                              underlyingError:jsonError
+                                  description:jsonError.localizedDescription];
+    return nil;
+  }
+  if (![json isKindOfClass:[NSDictionary class]]) {
+    *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeInvalidDiscoveryDocument
+                              underlyingError:nil
+                                  description:@"Discovery document isn't a dictionary"];
+    return nil;
+  }
+
+  return [self initWithDictionary:json error:error];
+}
+
+- (nullable instancetype)initWithDictionary:(NSDictionary *)serviceDiscoveryDictionary
+                                      error:(NSError **_Nullable)error {
+  if (![[self class] dictionaryHasRequiredFields:serviceDiscoveryDictionary error:error]) {
+    return nil;
+  }
+  self = [super init];
+  if (self) {
+    _discoveryDictionary = [serviceDiscoveryDictionary copy];
+  }
+  return self;
+}
+
+#pragma mark -
+
+/*! @brief Checks to see if the specified dictionary contains the required fields.
+    @discussion This test is not meant to provide semantic analysis of the document (eg. fields
+        where the value @c none is not an allowed option would not cause this method to fail if
+        their value was @c none.) We are just testing to make sure we can meet the nullability
+        contract we promised in the header.
+ */
++ (BOOL)dictionaryHasRequiredFields:(NSDictionary<NSString *, id> *)dictionary
+                              error:(NSError **_Nullable)error {
+  static NSString *const kMissingFieldErrorText = @"Missing field: %@";
+  static NSString *const kInvalidURLFieldErrorText = @"Invalid URL: %@";
+
+  NSArray *requiredFields = @[
+    kIssuerKey,
+    kAuthorizationEndpointKey,
+    kTokenEndpointKey,
+    kJWKSURLKey,
+    kResponseTypesSupportedKey,
+    kSubjectTypesSupportedKey,
+    kIDTokenSigningAlgorithmValuesSupportedKey
+  ];
+
+  for (NSString *field in requiredFields) {
+    if (!dictionary[field]) {
+      if (error) {
+        NSString *errorText = [NSString stringWithFormat:kMissingFieldErrorText, field];
+        *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeInvalidDiscoveryDocument
+                                  underlyingError:nil
+                                      description:errorText];
+      }
+      return NO;
+    }
+  }
+
+  // Check required URL fields are valid URLs.
+  NSArray *requiredURLFields = @[
+    kIssuerKey,
+    kTokenEndpointKey,
+    kJWKSURLKey
+  ];
+
+  for (NSString *field in requiredURLFields) {
+    if (![NSURL URLWithString:dictionary[field]]) {
+      if (error) {
+        NSString *errorText = [NSString stringWithFormat:kInvalidURLFieldErrorText, field];
+        *error = [OIDErrorUtilities errorWithCode:OIDErrorCodeInvalidDiscoveryDocument
+                                  underlyingError:nil
+                                      description:errorText];
+      }
+      return NO;
+    }
+  }
+
+  return YES;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder {
+  NSError *error;
+  NSDictionary *dictionary = [[NSDictionary alloc] initWithCoder:aDecoder];
+  self = [self initWithDictionary:dictionary error:&error];
+  if (error) {
+    return nil;
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [_discoveryDictionary encodeWithCoder:aCoder];
+}
+
+#pragma mark - Properties
+
+- (NSDictionary<NSString *, NSString *> *)discoveryDictionary {
+  return _discoveryDictionary;
+}
+
+- (NSURL *)issuer {
+  return [NSURL URLWithString:_discoveryDictionary[kIssuerKey]];
+}
+
+- (NSURL *)authorizationEndpoint {
+  return [NSURL URLWithString:_discoveryDictionary[kAuthorizationEndpointKey]];
+}
+
+- (NSURL *)tokenEndpoint {
+  return [NSURL URLWithString:_discoveryDictionary[kTokenEndpointKey]];
+}
+
+- (nullable NSURL *)userinfoEndpoint {
+  return [NSURL URLWithString:_discoveryDictionary[kUserinfoEndpointKey]];
+}
+
+- (NSURL *)jwksURL {
+  return [NSURL URLWithString:_discoveryDictionary[kJWKSURLKey]];
+}
+
+- (nullable NSURL *)registrationEndpoint {
+  return [NSURL URLWithString:_discoveryDictionary[kRegistrationEndpointKey]];
+}
+
+- (nullable NSURL *)endSessionEndpoint {
+    return [NSURL URLWithString:_discoveryDictionary[kEndSessionEndpointKey]];
+}
+
+- (nullable NSArray<NSString *> *)scopesSupported {
+  return _discoveryDictionary[kScopesSupportedKey];
+}
+
+- (NSArray<NSString *> *)responseTypesSupported {
+  return _discoveryDictionary[kResponseTypesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)responseModesSupported {
+  return _discoveryDictionary[kResponseModesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)grantTypesSupported {
+  return _discoveryDictionary[kGrantTypesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)acrValuesSupported {
+  return _discoveryDictionary[kACRValuesSupportedKey];
+}
+
+- (NSArray<NSString *> *)subjectTypesSupported {
+  return _discoveryDictionary[kSubjectTypesSupportedKey];
+}
+
+- (NSArray<NSString *> *) IDTokenSigningAlgorithmValuesSupported {
+  return _discoveryDictionary[kIDTokenSigningAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)IDTokenEncryptionAlgorithmValuesSupported {
+  return _discoveryDictionary[kIDTokenEncryptionAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)IDTokenEncryptionEncodingValuesSupported {
+  return _discoveryDictionary[kIDTokenEncryptionEncodingValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)userinfoSigningAlgorithmValuesSupported {
+  return _discoveryDictionary[kUserinfoSigningAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)userinfoEncryptionAlgorithmValuesSupported {
+  return _discoveryDictionary[kUserinfoEncryptionAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)userinfoEncryptionEncodingValuesSupported {
+  return _discoveryDictionary[kUserinfoEncryptionEncodingValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)requestObjectSigningAlgorithmValuesSupported {
+  return _discoveryDictionary[kRequestObjectSigningAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *) requestObjectEncryptionAlgorithmValuesSupported {
+  return _discoveryDictionary[kRequestObjectEncryptionAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *) requestObjectEncryptionEncodingValuesSupported {
+  return _discoveryDictionary[kRequestObjectEncryptionEncodingValuesSupported];
+}
+
+- (nullable NSArray<NSString *> *)tokenEndpointAuthMethodsSupported {
+  return _discoveryDictionary[kTokenEndpointAuthMethodsSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)tokenEndpointAuthSigningAlgorithmValuesSupported {
+  return _discoveryDictionary[kTokenEndpointAuthSigningAlgorithmValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)displayValuesSupported {
+  return _discoveryDictionary[kDisplayValuesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)claimTypesSupported {
+  return _discoveryDictionary[kClaimTypesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)claimsSupported {
+  return _discoveryDictionary[kClaimsSupportedKey];
+}
+
+- (nullable NSURL *)serviceDocumentation {
+  return [NSURL URLWithString:_discoveryDictionary[kServiceDocumentationKey]];
+}
+
+- (nullable NSArray<NSString *> *)claimsLocalesSupported {
+  return _discoveryDictionary[kClaimsLocalesSupportedKey];
+}
+
+- (nullable NSArray<NSString *> *)UILocalesSupported {
+  return _discoveryDictionary[kUILocalesSupportedKey];
+}
+
+- (BOOL)claimsParameterSupported {
+  return [_discoveryDictionary[kClaimsParameterSupportedKey] boolValue];
+}
+
+- (BOOL)requestParameterSupported {
+  return [_discoveryDictionary[kRequestParameterSupportedKey] boolValue];
+}
+
+- (BOOL)requestURIParameterSupported {
+  // Default is true/YES.
+  if (!_discoveryDictionary[kRequestURIParameterSupportedKey]) {
+    return YES;
+  }
+  return [_discoveryDictionary[kRequestURIParameterSupportedKey] boolValue];
+}
+
+- (BOOL)requireRequestURIRegistration {
+  return [_discoveryDictionary[kRequireRequestURIRegistrationKey] boolValue];
+}
+
+- (nullable NSURL *)OPPolicyURI {
+  return [NSURL URLWithString:_discoveryDictionary[kOPPolicyURIKey]];
+}
+
+- (nullable NSURL *)OPTosURI {
+  return [NSURL URLWithString:_discoveryDictionary[kOPTosURIKey]];
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDTokenRequest.h

@@ -0,0 +1,162 @@
+/*! @file OIDTokenRequest.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+// This file only declares string constants useful for constructing a @c OIDTokenRequest, so it is
+// imported here for convenience.
+#import "OIDGrantTypes.h"
+
+@class OIDAuthorizationResponse;
+@class OIDServiceConfiguration;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents a token request.
+    @see https://tools.ietf.org/html/rfc6749#section-3.2
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+@interface OIDTokenRequest : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The service's configuration.
+    @remarks This configuration specifies how to connect to a particular OAuth provider.
+        Configurations may be created manually, or via an OpenID Connect Discovery Document.
+ */
+@property(nonatomic, readonly) OIDServiceConfiguration *configuration;
+
+/*! @brief The type of token being sent to the token endpoint, i.e. "authorization_code" for the
+        authorization code exchange, or "refresh_token" for an access token refresh request.
+    @remarks grant_type
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+    @see https://www.google.com/url?sa=D&q=https%3A%2F%2Ftools.ietf.org%2Fhtml%2Frfc6749%23section-6
+ */
+@property(nonatomic, readonly) NSString *grantType;
+
+/*! @brief The authorization code received from the authorization server.
+    @remarks code
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+@property(nonatomic, readonly, nullable) NSString *authorizationCode;
+
+/*! @brief The client's redirect URI.
+    @remarks redirect_uri
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+@property(nonatomic, readonly, nullable) NSURL *redirectURL;
+
+/*! @brief The client identifier.
+    @remarks client_id
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+@property(nonatomic, readonly) NSString *clientID;
+
+/*! @brief The client secret.
+    @remarks client_secret
+    @see https://tools.ietf.org/html/rfc6749#section-2.3.1
+ */
+@property(nonatomic, readonly, nullable) NSString *clientSecret;
+
+/*! @brief The value of the scope parameter is expressed as a list of space-delimited,
+        case-sensitive strings.
+    @remarks scope
+    @see https://tools.ietf.org/html/rfc6749#section-3.3
+ */
+@property(nonatomic, readonly, nullable) NSString *scope;
+
+/*! @brief The refresh token, which can be used to obtain new access tokens using the same
+        authorization grant.
+    @remarks refresh_token
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *refreshToken;
+
+/*! @brief The PKCE code verifier used to redeem the authorization code.
+    @remarks code_verifier
+    @see https://tools.ietf.org/html/rfc7636#section-4.3
+ */
+@property(nonatomic, readonly, nullable) NSString *codeVerifier;
+
+/*! @brief The client's additional token request parameters.
+ */
+@property(nonatomic, readonly, nullable) NSDictionary<NSString *, NSString *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use
+        initWithConfiguration:grantType:code:redirectURL:clientID:additionalParameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @param configuration The service's configuration.
+    @param grantType the type of token being sent to the token endpoint, i.e. "authorization_code"
+        for the authorization code exchange, or "refresh_token" for an access token refresh request.
+        @see OIDGrantTypes.h
+    @param code The authorization code received from the authorization server.
+    @param redirectURL The client's redirect URI.
+    @param clientID The client identifier.
+    @param clientSecret The client secret.
+    @param scopes An array of scopes to combine into a single scope string per the OAuth2 spec.
+    @param refreshToken The refresh token.
+    @param codeVerifier The PKCE code verifier.
+    @param additionalParameters The client's additional token request parameters.
+ */
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               grantType:(NSString *)grantType
+       authorizationCode:(nullable NSString *)code
+             redirectURL:(nullable NSURL *)redirectURL
+                clientID:(NSString *)clientID
+            clientSecret:(nullable NSString *)clientSecret
+                  scopes:(nullable NSArray<NSString *> *)scopes
+            refreshToken:(nullable NSString *)refreshToken
+            codeVerifier:(nullable NSString *)codeVerifier
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters;
+
+/*! @brief Designated initializer.
+    @param configuration The service's configuration.
+    @param grantType the type of token being sent to the token endpoint, i.e. "authorization_code"
+        for the authorization code exchange, or "refresh_token" for an access token refresh request.
+        @see OIDGrantTypes.h
+    @param code The authorization code received from the authorization server.
+    @param redirectURL The client's redirect URI.
+    @param clientID The client identifier.
+    @param clientSecret The client secret.
+    @param scope The value of the scope parameter is expressed as a list of space-delimited,
+        case-sensitive strings.
+    @param refreshToken The refresh token.
+    @param codeVerifier The PKCE code verifier.
+    @param additionalParameters The client's additional token request parameters.
+ */
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               grantType:(NSString *)grantType
+       authorizationCode:(nullable NSString *)code
+             redirectURL:(nullable NSURL *)redirectURL
+                clientID:(NSString *)clientID
+            clientSecret:(nullable NSString *)clientSecret
+                   scope:(nullable NSString *)scope
+            refreshToken:(nullable NSString *)refreshToken
+            codeVerifier:(nullable NSString *)codeVerifier
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters
+    NS_DESIGNATED_INITIALIZER;
+
+/*! @brief Constructs an @c NSURLRequest representing the token request.
+    @return An @c NSURLRequest representing the token request.
+ */
+- (NSURLRequest *)URLRequest;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/AppAuth/Source/AppAuthCore/OIDTokenRequest.m

@@ -0,0 +1,307 @@
+/*! @file OIDTokenRequest.m
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import "OIDTokenRequest.h"
+
+#import "OIDDefines.h"
+#import "OIDError.h"
+#import "OIDScopeUtilities.h"
+#import "OIDServiceConfiguration.h"
+#import "OIDURLQueryComponent.h"
+#import "OIDTokenUtilities.h"
+
+/*! @brief The key for the @c configuration property for @c NSSecureCoding
+ */
+static NSString *const kConfigurationKey = @"configuration";
+
+/*! @brief Key used to encode the @c grantType property for @c NSSecureCoding
+ */
+static NSString *const kGrantTypeKey = @"grant_type";
+
+/*! @brief The key for the @c authorizationCode property for @c NSSecureCoding.
+ */
+static NSString *const kAuthorizationCodeKey = @"code";
+
+/*! @brief Key used to encode the @c clientID property for @c NSSecureCoding
+ */
+static NSString *const kClientIDKey = @"client_id";
+
+/*! @brief Key used to encode the @c clientSecret property for @c NSSecureCoding
+ */
+static NSString *const kClientSecretKey = @"client_secret";
+
+/*! @brief Key used to encode the @c redirectURL property for @c NSSecureCoding
+ */
+static NSString *const kRedirectURLKey = @"redirect_uri";
+
+/*! @brief Key used to encode the @c scopes property for @c NSSecureCoding
+ */
+static NSString *const kScopeKey = @"scope";
+
+/*! @brief Key used to encode the @c refreshToken property for @c NSSecureCoding
+ */
+static NSString *const kRefreshTokenKey = @"refresh_token";
+
+/*! @brief Key used to encode the @c codeVerifier property for @c NSSecureCoding and to build the
+        request URL.
+ */
+static NSString *const kCodeVerifierKey = @"code_verifier";
+
+/*! @brief Key used to encode the @c additionalParameters property for
+        @c NSSecureCoding
+ */
+static NSString *const kAdditionalParametersKey = @"additionalParameters";
+
+@implementation OIDTokenRequest
+
+- (instancetype)init
+    OID_UNAVAILABLE_USE_INITIALIZER(
+        @selector(initWithConfiguration:
+                              grantType:
+                      authorizationCode:
+                            redirectURL:
+                               clientID:
+                           clientSecret:
+                                  scope:
+                           refreshToken:
+                           codeVerifier:
+                   additionalParameters:)
+    )
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               grantType:(NSString *)grantType
+       authorizationCode:(nullable NSString *)code
+             redirectURL:(nullable NSURL *)redirectURL
+                clientID:(NSString *)clientID
+            clientSecret:(nullable NSString *)clientSecret
+                  scopes:(nullable NSArray<NSString *> *)scopes
+            refreshToken:(nullable NSString *)refreshToken
+            codeVerifier:(nullable NSString *)codeVerifier
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  return [self initWithConfiguration:configuration
+                           grantType:grantType
+                   authorizationCode:code
+                         redirectURL:redirectURL
+                            clientID:clientID
+                        clientSecret:clientSecret
+                               scope:[OIDScopeUtilities scopesWithArray:scopes]
+                        refreshToken:refreshToken
+                        codeVerifier:(NSString *)codeVerifier
+                additionalParameters:additionalParameters];
+}
+
+- (instancetype)initWithConfiguration:(OIDServiceConfiguration *)configuration
+               grantType:(NSString *)grantType
+       authorizationCode:(nullable NSString *)code
+             redirectURL:(nullable NSURL *)redirectURL
+                clientID:(NSString *)clientID
+            clientSecret:(nullable NSString *)clientSecret
+                   scope:(nullable NSString *)scope
+            refreshToken:(nullable NSString *)refreshToken
+            codeVerifier:(nullable NSString *)codeVerifier
+    additionalParameters:(nullable NSDictionary<NSString *, NSString *> *)additionalParameters {
+  self = [super init];
+  if (self) {
+    _configuration = [configuration copy];
+    _grantType = [grantType copy];
+    _authorizationCode = [code copy];
+    _redirectURL = [redirectURL copy];
+    _clientID = [clientID copy];
+    _clientSecret = [clientSecret copy];
+    _scope = [scope copy];
+    _refreshToken = [refreshToken copy];
+    _codeVerifier = [codeVerifier copy];
+    _additionalParameters =
+        [[NSDictionary alloc] initWithDictionary:additionalParameters copyItems:YES];
+    
+    // Additional validation for the authorization_code grant type
+    if ([_grantType isEqual:OIDGrantTypeAuthorizationCode]) {
+      // redirect URI must not be nil
+      if (!_redirectURL) {
+        [NSException raise:OIDOAuthExceptionInvalidTokenRequestNullRedirectURL
+                    format:@"%@", OIDOAuthExceptionInvalidTokenRequestNullRedirectURL, nil];
+
+      }
+    }
+  }
+  return self;
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(nullable NSZone *)zone {
+  // The documentation for NSCopying specifically advises us to return a reference to the original
+  // instance in the case where instances are immutable (as ours is):
+  // "Implement NSCopying by retaining the original instead of creating a new copy when the class
+  // and its contents are immutable."
+  return self;
+}
+
+#pragma mark - NSSecureCoding
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  OIDServiceConfiguration *configuration =
+      [aDecoder decodeObjectOfClass:[OIDServiceConfiguration class]
+                             forKey:kConfigurationKey];
+  NSString *grantType = [aDecoder decodeObjectOfClass:[NSString class] forKey:kGrantTypeKey];
+  NSString *code = [aDecoder decodeObjectOfClass:[NSString class] forKey:kAuthorizationCodeKey];
+  NSString *clientID = [aDecoder decodeObjectOfClass:[NSString class] forKey:kClientIDKey];
+  NSString *clientSecret = [aDecoder decodeObjectOfClass:[NSString class] forKey:kClientSecretKey];
+  NSString *scope = [aDecoder decodeObjectOfClass:[NSString class] forKey:kScopeKey];
+  NSString *refreshToken = [aDecoder decodeObjectOfClass:[NSString class] forKey:kRefreshTokenKey];
+  NSString *codeVerifier = [aDecoder decodeObjectOfClass:[NSString class] forKey:kCodeVerifierKey];
+  NSURL *redirectURL = [aDecoder decodeObjectOfClass:[NSURL class] forKey:kRedirectURLKey];
+  NSSet *additionalParameterCodingClasses = [NSSet setWithArray:@[
+    [NSDictionary class],
+    [NSString class]
+  ]];
+  NSDictionary *additionalParameters =
+      [aDecoder decodeObjectOfClasses:additionalParameterCodingClasses
+                               forKey:kAdditionalParametersKey];
+  self = [self initWithConfiguration:configuration
+                           grantType:grantType
+                   authorizationCode:code
+                         redirectURL:redirectURL
+                            clientID:clientID
+                        clientSecret:clientSecret
+                               scope:scope
+                        refreshToken:refreshToken
+                        codeVerifier:codeVerifier
+                additionalParameters:additionalParameters];
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_configuration forKey:kConfigurationKey];
+  [aCoder encodeObject:_grantType forKey:kGrantTypeKey];
+  [aCoder encodeObject:_authorizationCode forKey:kAuthorizationCodeKey];
+  [aCoder encodeObject:_clientID forKey:kClientIDKey];
+  [aCoder encodeObject:_clientSecret forKey:kClientSecretKey];
+  [aCoder encodeObject:_redirectURL forKey:kRedirectURLKey];
+  [aCoder encodeObject:_scope forKey:kScopeKey];
+  [aCoder encodeObject:_refreshToken forKey:kRefreshTokenKey];
+  [aCoder encodeObject:_codeVerifier forKey:kCodeVerifierKey];
+  [aCoder encodeObject:_additionalParameters forKey:kAdditionalParametersKey];
+}
+
+#pragma mark - NSObject overrides
+
+- (NSString *)description {
+  NSURLRequest *request = self.URLRequest;
+  NSString *requestBody =
+      [[NSString alloc] initWithData:request.HTTPBody encoding:NSUTF8StringEncoding];
+  return [NSString stringWithFormat:@"<%@: %p, request: <URL: %@, HTTPBody: %@>>",
+                                    NSStringFromClass([self class]),
+                                    (void *)self,
+                                    request.URL,
+                                    requestBody];
+}
+
+#pragma mark -
+
+/*! @brief Constructs the request URI.
+    @return A URL representing the token request.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+- (NSURL *)tokenRequestURL {
+  return _configuration.tokenEndpoint;
+}
+
+/*! @brief Constructs the request body data by combining the request parameters using the
+        "application/x-www-form-urlencoded" format.
+    @return The data to pass to the token request URL.
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+- (OIDURLQueryComponent *)tokenRequestBody {
+  OIDURLQueryComponent *query = [[OIDURLQueryComponent alloc] init];
+
+  // Add parameters, as applicable.
+  if (_grantType) {
+    [query addParameter:kGrantTypeKey value:_grantType];
+  }
+  if (_scope) {
+    [query addParameter:kScopeKey value:_scope];
+  }
+  if (_redirectURL) {
+    [query addParameter:kRedirectURLKey value:_redirectURL.absoluteString];
+  }
+  if (_refreshToken) {
+    [query addParameter:kRefreshTokenKey value:_refreshToken];
+  }
+  if (_authorizationCode) {
+    [query addParameter:kAuthorizationCodeKey value:_authorizationCode];
+  }
+  if (_codeVerifier) {
+    [query addParameter:kCodeVerifierKey value:_codeVerifier];
+  }
+
+  // Add any additional parameters the client has specified.
+  [query addParameters:_additionalParameters];
+
+  return query;
+}
+
+- (NSURLRequest *)URLRequest {
+  static NSString *const kHTTPPost = @"POST";
+  static NSString *const kHTTPContentTypeHeaderKey = @"Content-Type";
+  static NSString *const kHTTPContentTypeHeaderValue =
+      @"application/x-www-form-urlencoded; charset=UTF-8";
+
+  NSURL *tokenRequestURL = [self tokenRequestURL];
+  NSMutableURLRequest *URLRequest = [[NSURLRequest requestWithURL:tokenRequestURL] mutableCopy];
+  URLRequest.HTTPMethod = kHTTPPost;
+  [URLRequest setValue:kHTTPContentTypeHeaderValue forHTTPHeaderField:kHTTPContentTypeHeaderKey];
+
+  OIDURLQueryComponent *bodyParameters = [self tokenRequestBody];
+  NSMutableDictionary *httpHeaders = [[NSMutableDictionary alloc] init];
+
+  if (_clientSecret) {
+    // The client id and secret are encoded using the "application/x-www-form-urlencoded" 
+    // encoding algorithm per RFC 6749 Section 2.3.1.
+    // https://tools.ietf.org/html/rfc6749#section-2.3.1
+    NSString *encodedClientID = [OIDTokenUtilities formUrlEncode:_clientID];
+    NSString *encodedClientSecret = [OIDTokenUtilities formUrlEncode:_clientSecret];
+    
+    NSString *credentials =
+        [NSString stringWithFormat:@"%@:%@", encodedClientID, encodedClientSecret];
+    NSData *plainData = [credentials dataUsingEncoding:NSUTF8StringEncoding];
+    NSString *basicAuth = [plainData base64EncodedStringWithOptions:kNilOptions];
+
+    NSString *authValue = [NSString stringWithFormat:@"Basic %@", basicAuth];
+    [httpHeaders setObject:authValue forKey:@"Authorization"];
+  } else  {
+    [bodyParameters addParameter:kClientIDKey value:_clientID];
+  }
+
+  // Constructs request with the body string and headers.
+  NSString *bodyString = [bodyParameters URLEncodedParameters];
+  NSData *body = [bodyString dataUsingEncoding:NSUTF8StringEncoding];
+  URLRequest.HTTPBody = body;
+
+  for (id header in httpHeaders) {
+    [URLRequest setValue:httpHeaders[header] forHTTPHeaderField:header];
+  }
+
+  return URLRequest;
+}
+
+@end

Pods/AppAuth/Source/AppAuthCore/OIDTokenResponse.h

@@ -0,0 +1,110 @@
+/*! @file OIDTokenResponse.h
+    @brief AppAuth iOS SDK
+    @copyright
+        Copyright 2015 Google Inc. All Rights Reserved.
+    @copydetails
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class OIDTokenRequest;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*! @brief Represents the response to an token request.
+    @see https://tools.ietf.org/html/rfc6749#section-3.2
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+@interface OIDTokenResponse : NSObject <NSCopying, NSSecureCoding>
+
+/*! @brief The request which was serviced.
+ */
+@property(nonatomic, readonly) OIDTokenRequest *request;
+
+/*! @brief The access token generated by the authorization server.
+    @remarks access_token
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.4
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *accessToken;
+
+/*! @brief The approximate expiration date & time of the access token.
+    @remarks expires_in
+    @seealso OIDTokenResponse.accessToken
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.4
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSDate *accessTokenExpirationDate;
+
+/*! @brief Typically "Bearer" when present. Otherwise, another token_type value that the Client has
+        negotiated with the Authorization Server.
+    @remarks token_type
+    @see https://tools.ietf.org/html/rfc6749#section-4.1.4
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *tokenType;
+
+/*! @brief ID Token value associated with the authenticated session. Always present for the
+        authorization code grant exchange when OpenID Connect is used, optional for responses to
+        access token refresh requests. Note that AppAuth does NOT verify the JWT signature. Users
+        of AppAuth are encouraged to verifying the JWT signature using the validation library of
+        their choosing.
+    @remarks id_token
+    @see http://openid.net/specs/openid-connect-core-1_0.html#TokenResponse
+    @see http://openid.net/specs/openid-connect-core-1_0.html#RefreshTokenResponse
+    @see http://openid.net/specs/openid-connect-core-1_0.html#IDToken
+    @see https://jwt.io
+    @discussion @c OIDIDToken can be used to parse the ID Token and extract the claims. As noted,
+        this class does not verify the JWT signature.
+*/
+@property(nonatomic, readonly, nullable) NSString *idToken;
+
+/*! @brief The refresh token, which can be used to obtain new access tokens using the same
+        authorization grant
+    @remarks refresh_token
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *refreshToken;
+
+/*! @brief The scope of the access token. OPTIONAL, if identical to the scopes requested, otherwise,
+        REQUIRED.
+    @remarks scope
+    @see https://tools.ietf.org/html/rfc6749#section-5.1
+ */
+@property(nonatomic, readonly, nullable) NSString *scope;
+
+/*! @brief Additional parameters returned from the token server.
+ */
+@property(nonatomic, readonly, nullable)
+    NSDictionary<NSString *, NSObject<NSCopying> *> *additionalParameters;
+
+/*! @internal
+    @brief Unavailable. Please use initWithParameters:.
+ */
+- (instancetype)init NS_UNAVAILABLE;
+
+/*! @brief Designated initializer.
+    @param request The serviced request.
+    @param parameters The decoded parameters returned from the Authorization Server.
+    @remarks Known parameters are extracted from the @c parameters parameter and the normative
+        properties are populated. Non-normative parameters are placed in the
+        @c #additionalParameters dictionary.
+ */
+- (instancetype)initWithRequest:(OIDTokenRequest *)request
+                     parameters:(NSDictionary<NSString *, NSObject<NSCopying> *> *)parameters
+                     NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END