README.md

@@ -13,7 +13,7 @@ To use this library, then add it as a dependency in the `Package.swift` file of
 let package = Package(
     // name, platforms, products, etc.
     dependencies: [
-        .package(url: "https://github.com/rock-n-code/discogs-service", from: "0.2.0"),
+        .package(url: "https://github.com/rock-n-code/discogs-service", from: "0.3.0"),
         // other dependencies
     ],
     targets: [

Sources/DiscogsService/Catalogs/DiscogsService.docc/Library.md

@@ -22,6 +22,12 @@
 - ``AuthMethod``
 - ``AuthTransport``
 
+### User Agent
+
+- ``UserAgentMiddleware``
+- ``Product``
+- ``InputValidationError``
+
 ### Types
 
 - ``Components``

Sources/DiscogsService/Internal/Extensions/String+Functions.swift

@@ -0,0 +1,45 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+import Foundation
+
+extension String {
+    
+    // MARK: Functions
+    
+    /// Checks whether a regular expression pattern fully matches a string or not.
+    /// - Parameter pattern: A regular expression pattern to match a string against.
+    /// - Returns: A flag that indicates whether a given pattern fully matches a string or not.
+    func fullyMatch(pattern: String) -> Bool {
+        do {
+            if #available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 6.0, *) {
+                let securityInput = try Regex(pattern)
+                let matches = self.wholeMatch(of: securityInput)
+                
+                return matches != nil
+            } else {
+                let securityInput = try NSRegularExpression(pattern: pattern)
+                let matches = securityInput.matches(
+                    in: self,
+                    range: .init(location: 0, length: count)
+                )
+                
+                return !matches.isEmpty
+            }
+        } catch {
+            return false
+        }
+    }
+    
+}

Sources/DiscogsService/Internal/Validation Rules/CamelCaseValidationRule.swift

@@ -0,0 +1,77 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+/// A validation rule type that checks whether an input is camel-case or not.
+struct CamelCaseValidationRule: InputValidationRule {
+    
+    // MARK: Functions
+    
+#if swift(>=6.0)
+    func validate(_ input: String?) throws(InputValidationError) -> Bool {
+        try validate(input: input)
+    }
+#else
+    func validate(_ input: String?) throws -> Bool {
+        try validate(input: input)
+    }
+#endif
+    
+}
+
+// MARK: - Definitions
+
+extension InputValidationRule where Self == CamelCaseValidationRule {
+    
+    // MARK: Constants
+    
+    /// A validation rule that checks whether an input is camel-cased or not.
+    static var camelCase: Self { .init() }
+    
+}
+
+// MARK: - Helpers
+
+private extension CamelCaseValidationRule {
+    
+    // MARK: Functions
+
+    /// Validates a given input.
+    ///
+    /// > note: This helper function would not be necessary when support for *Swift 5.10* is discontinued.
+    ///
+    /// - Parameter input: An input to be validated.
+    /// - Returns: A flag that indicates whether a given input has been validated or not.
+    /// - Throws: An error of type ``InputValidatorError`` in case the validation failed.
+    func validate(input: String?) throws -> Bool {
+        guard let input else {
+            return false
+        }
+        
+        guard input.fullyMatch(
+            pattern: .init(format: .Pattern.camelCase)
+        ) else {
+            throw InputValidationError.inputNotCamelCase
+        }
+        
+        return true
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension String.Pattern {
+    /// A regular expression pattern that represents camel-cased inputs.
+    static let camelCase = "([A-Z]([a-z]|[0-9])+)+"
+}

Sources/DiscogsService/Internal/Validation Rules/SecureValidationRule.swift

@@ -77,32 +77,6 @@ private extension SecureValidationRule {
     
     // MARK: Functions
     
-    /// Checks if a given input is valid,
-    /// - Parameter input: An input to validate.
-    /// - Returns: A flag that indicates whether a given input is valid or not.
-    func isValid(_ input: String) -> Bool {
-        let regexPattern = String(format: .Pattern.securityInput, inputType.rawValue)
-
-        do {
-            if #available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 6.0, *) {
-                let securityInput = try Regex(regexPattern)
-                let matches = input.matches(of: securityInput)
-                
-                return !matches.isEmpty
-            } else {
-                let securityInput = try NSRegularExpression(pattern: regexPattern)
-                let matches = securityInput.matches(
-                    in: input,
-                    range: .init(location: 0, length: input.count)
-                )
-                
-                return !matches.isEmpty
-            }
-        } catch {
-            return false
-        }
-    }
-    
     /// Validates a given input.
     ///
     /// > note: This helper function would not be necessary when support for *Swift 5.10* is discontinued.
@@ -114,7 +88,10 @@ private extension SecureValidationRule {
         guard let input else {
             return false
         }
-        guard isValid(input) else {
+
+        guard input.fullyMatch(
+            pattern: .init(format: .Pattern.securityInput, inputType.rawValue)
+        ) else {
             switch inputType {
             case .consumerKey: throw InputValidationError.inputNotConsumerKey
             case .consumerSecret: throw InputValidationError.inputNotConsumerSecret
@@ -130,6 +107,6 @@ private extension SecureValidationRule {
 // MARK: - Constants
 
 private extension String.Pattern {
-    /// A regular expression pattern to match the security inputs against.
+    /// A regular expression pattern that represents security inputs.
     static let securityInput = "^([a-z]|[A-Z]){%d}$"
 }

Sources/DiscogsService/Internal/Validation Rules/SemanticVersionValidationRule.swift

@@ -0,0 +1,81 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+/// A validation rule type that checks whether an input is a semantic version or not.
+///
+/// This validation rules follows the principles defined in the [Semantic Versioning 2.0.0 documentation](https://semver.org/spec/v2.0.0.html)
+struct SemanticVersionValidationRule: InputValidationRule {
+    
+    // MARK: Functions
+    
+#if swift(>=6.0)
+    func validate(_ input: String?) throws(InputValidationError) -> Bool {
+        try validate(input: input)
+    }
+#else
+    func validate(_ input: String?) throws -> Bool {
+        try validate(input: input)
+    }
+#endif
+    
+}
+
+// MARK: - Definitions
+
+extension InputValidationRule where Self == SemanticVersionValidationRule {
+    
+    // MARK: Constants
+    
+    /// A validation rule that checks whether an input is semantic version or not.
+    static var semanticVersion: Self { .init() }
+    
+}
+
+// MARK: - Helpers
+
+private extension SemanticVersionValidationRule {
+    
+    // MARK: Functions
+    
+    /// Validates a given input.
+    ///
+    /// > note: This helper function would not be necessary when support for *Swift 5.10* is discontinued.
+    ///
+    /// - Parameter input: An input to be validated.
+    /// - Returns: A flag that indicates whether a given input has been validated or not.
+    /// - Throws: An error of type ``InputValidatorError`` in case the validation failed.
+    func validate(input: String?) throws -> Bool {
+        guard let input else {
+            return false
+        }
+        
+        guard input.fullyMatch(
+            pattern: .init(format: .Pattern.semanticVersioning)
+        ) else {
+            throw InputValidationError.inputNotSemanticVersion
+        }
+        
+        return true
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension String.Pattern {
+    /// A regular expression pattern that represents semantic version inputs.
+    ///
+    /// This regular expression is based on the [suggested regular expression](https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string) of the *Semantic Versioning 2.0.0* documentation.
+    static let semanticVersioning = "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-((?:0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$"
+}

Sources/DiscogsService/Internal/Validation Rules/URLValidationRule.swift

@@ -0,0 +1,83 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+/// A validation rule type that checks whether an input is a URL or not.
+///
+/// This validation rule doesn't necessarily follow the [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986) standard.
+/// Thus it doesn't implement a complex regular expression pattern such as [this one](https://rgxdb.com/r/5JXUI5A2).
+/// Instead this validation implements a regular expression sufficient enough to satisfy the requirements for a [user agent definition](https://www.discogs.com/developers/#page:home,header:home-general-information).
+struct URLValidationRule: InputValidationRule {
+    
+    // MARK: Functions
+    
+#if swift(>=6.0)
+    func validate(_ input: String?) throws(InputValidationError) -> Bool {
+        try validate(input: input)
+    }
+#else
+    func validate(_ input: String?) throws -> Bool {
+        try validate(input: input)
+    }
+#endif
+    
+}
+
+// MARK: - Definitions
+
+extension InputValidationRule where Self == URLValidationRule {
+    
+    // MARK: Constants
+    
+    /// A validation rule that checks whether an input is a URL or not.
+    static var url: Self { .init() }
+    
+}
+
+// MARK: - Helpers
+
+private extension URLValidationRule {
+    
+    // MARK: Functions
+    
+    /// Validates a given input.
+    ///
+    /// > note: This helper function would not be necessary when support for *Swift 5.10* is discontinued.
+    ///
+    /// - Parameter input: An input to be validated.
+    /// - Returns: A flag that indicates whether a given input has been validated or not.
+    /// - Throws: An error of type ``InputValidatorError`` in case the validation failed.
+    func validate(input: String?) throws -> Bool {
+        guard let input else {
+            return false
+        }
+        
+        guard input.fullyMatch(
+            pattern: .init(format: .Pattern.url)
+        ) else {
+            throw InputValidationError.inputNotURL
+        }
+        
+        return true
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension String.Pattern {
+    /// A regular expression pattern that represents URL inputs.
+    ///
+    /// This regular expression is based on [this regular expression](https://regex101.com/r/3fYy3x/1) found while researching the topic.
+    static let url = "https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\\.[a-z]{2,4}\\b([-a-zA-Z0-9@:%_\\+.~#?&//=]*)"
+}

Sources/DiscogsService/Public/Errors/InputValidationError.swift

@@ -13,15 +13,21 @@
 // ===----------------------------------------------------------------------===
 
 /// A representation of all the possible validation error that could be thrown while validating an input.
-enum InputValidationError: Error {
+public enum InputValidationError: Error {
     /// An input is empty.
     case inputIsEmpty
     /// An input is nil.
     case inputIsNil
+    /// An input is not camel-case.
+    case inputNotCamelCase
     /// An input does not comply with the consumer key requirements.
     case inputNotConsumerKey
     /// An input does not comply with the consumer secret requirements.
     case inputNotConsumerSecret
+    /// An input is not a semantic version.
+    case inputNotSemanticVersion
+    /// An input is not a URL.
+    case inputNotURL
     /// An input does not comply with the user token requirements.
     case inputNotUserToken
 }

Sources/DiscogsService/Public/Middlewares/AuthMiddleware.swift

@@ -43,6 +43,7 @@ public struct AuthMiddleware {
     /// - Parameters:
     ///   - method: A representation of an authentication method to use to authenticate requests.
     ///   - transport: A representation of a transport option to send credentials in requests.
+    /// - Throws: An error of type ``InputValidationError`` in case an input failed any validation.
     public init(
         method: AuthMethod = .none,
         transport: AuthTransport

Sources/DiscogsService/Public/Middlewares/UserAgentMiddleware.swift

@@ -0,0 +1,109 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+import class OpenAPIRuntime.HTTPBody
+
+import protocol OpenAPIRuntime.ClientMiddleware
+
+import struct Foundation.URL
+import struct HTTPTypes.HTTPField
+import struct HTTPTypes.HTTPFields
+import struct HTTPTypes.HTTPRequest
+import struct HTTPTypes.HTTPResponse
+
+/// A middleware that attaches the user agent header into the requests to the service.
+///
+/// Please refer to the [Discogs documentation](https://www.discogs.com/developers/#page:home,header:home-general-information) for further information.
+public struct UserAgentMiddleware {
+    
+    // MARK: Properties
+
+    /// A formatted value for the user agent header.
+    let agentField: HTTPField
+    
+    // MARK: Initializers
+    
+    /// Initializes this middleware.
+    /// - Parameter product: A product from which the user agent will be generated from.
+    /// - Throws: An error of type ``InputValidationError`` in case an input failed any validation.
+    public init(product: Product) throws {
+        let agentName = ValidateInputUseCase(rules: .notNil, .notEmpty, .camelCase)
+        let agentVersion = ValidateInputUseCase(rules: .notNil, .notEmpty, .semanticVersion)
+        let agentURL = ValidateInputUseCase(rules: .notNil, .notEmpty, .url)
+        
+        try agentName(product.name)
+        try agentVersion(product.version)
+        try agentURL(product.url)
+        
+        self.agentField = .init(
+            name: .userAgent,
+            value: .init(format: .Format.userAgent, product.name, product.version, product.url)
+        )
+    }
+    
+}
+
+// MARK: - ClientMiddleware
+
+extension UserAgentMiddleware: ClientMiddleware {
+    
+    // MARK: Functions
+    
+    public func intercept(
+        _ request: HTTPRequest,
+        body: HTTPBody?,
+        baseURL: URL,
+        operationID: String,
+        next: @Sendable (HTTPRequest, HTTPBody?, URL) async throws -> (HTTPResponse, HTTPBody?)
+    ) async throws -> (HTTPResponse, HTTPBody?) {
+        return try await next(
+            .init(
+                method: request.method,
+                scheme: request.scheme,
+                authority: request.authority,
+                path: request.path,
+                headerFields: userAgentHeader(request.headerFields)
+            ),
+            body,
+            baseURL
+        )
+    }
+    
+}
+
+// MARK: - Helpers
+
+private extension UserAgentMiddleware {
+    
+    // MARK: Functions
+    
+    /// Adds a user agent header to the existing header fields.
+    /// - Parameter fields: A set of header fields to update.
+    /// - Returns: An updated set of header fields including the user agent header.
+    func userAgentHeader(_ fields: HTTPFields) -> HTTPFields {
+        var fields = fields
+        
+        fields.append(agentField)
+
+        return fields
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension String.Format {
+    /// A format for the user agent header.
+    static let userAgent = "%@/%@ +%@"
+}

Sources/DiscogsService/Public/Models/Product.swift

@@ -33,8 +33,8 @@ public struct Product: Sendable {
     /// Initializes this model.
     /// - Parameters:
     ///   - name: A camel-cased name of a product.
-    ///   - version: A URI link related to a product.
-    ///   - url: A semantic version of a product.
+    ///   - version: A semantic version of a product.
+    ///   - url: A URI link related to a product.
     public init(
         name: String,
         version: String,

Tests/DiscogsService/Cases/Internal/Extensions/String+FunctionsTests.swift

@@ -0,0 +1,99 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+import Testing
+
+@testable import DiscogsService
+
+@Suite("String Functions", .tags(.extension))
+struct StringFunctionsTests {
+    
+    // MARK: Functions tests
+    
+#if swift(>=6.2)
+    @Test(arguments: zip(
+        Input.stringsToMatch,
+        Output.stringsToMatch
+    ))
+    func `fully match`(
+        string: String,
+        expects isMatch: Bool
+    ) {
+        assertFullyMatch(
+            string: string,
+            pattern: .Pattern.sample,
+            expects: isMatch
+        )
+    }
+#else
+    @Test("fully match", arguments: zip(
+        Input.stringsToMatch,
+        Output.stringsToMatch
+    ))
+    func fullyMatch(
+        string: String,
+        expects isMatch: Bool
+    ) {
+        assertFullyMatch(
+            string: string,
+            pattern: .Pattern.sample,
+            expects: isMatch
+        )
+    }
+#endif
+    
+}
+
+// MARK: - Assertions
+
+private extension StringFunctionsTests {
+    
+    // MARK: Functions
+    
+    /// Asserts the result of the `fullyMatch` function.
+    /// - Parameters:
+    ///   - string: A string to match against a pattern.
+    ///   - pattern: A regular expression pattern to match a string against.
+    ///   - isMatch: An expected flag that indicates whether there is a match or not.
+    func assertFullyMatch(
+        string: String,
+        pattern: String,
+        expects isMatch: Bool
+    ) {
+        // GIVEN
+        // WHEN
+        let result = string.fullyMatch(pattern: pattern)
+
+        // THEN
+        #expect(result == isMatch)
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension Input {
+    /// A list of strings to match against a regular expression pattern in test cases.
+    static let stringsToMatch: [String] = ["Some Pattern", "Some", "Some Other Pattern", "Pattern", .empty]
+}
+
+private extension Output {
+    /// A list of expected results from matching a sample string against a sample regular expression pattern in test cases.
+    static let stringsToMatch: [Bool] = [true, false, false, false, false]
+}
+
+private extension String.Pattern {
+    /// A sample regular expression pattern to match against.
+    static let sample = "Some Pattern"
+}

Tests/DiscogsService/Cases/Internal/Use Cases/ValidateInputUseCaseTests.swift

@@ -22,6 +22,20 @@ struct ValidateInputUseCaseTests {
     // MARK: Functions
     
 #if swift(>=6.2)
+    @Test(arguments: zip(
+        Input.inputsAgentName,
+        Output.inputsAgentName
+    )) func `validate camel case`(
+        input: String,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .agentName,
+            input: input,
+            expects: error
+        )
+    }
+
     @Test(arguments: zip(
         Input.inputsNotEmpty,
         Output.inputsNotEmpty
@@ -91,7 +105,49 @@ struct ValidateInputUseCaseTests {
             expects: error
         )
     }
+    
+    @Test(arguments: zip(
+        Input.inputsSemanticVersion,
+        Output.inputsSemanticVersion
+    )) func `validate semantic version`(
+        input: String?,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .semanticVersion,
+            input: input,
+            expects: error
+        )
+    }
+    
+    @Test(arguments: zip(
+        Input.inputsURL,
+        Output.inputsURL
+    )) func `validate url`(
+        input: String?,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .url,
+            input: input,
+            expects: error
+        )
+    }
 #else
+    @Test("validate camel case", arguments: zip(
+        Input.inputsCamelCase,
+        Output.inputsCamelCase
+    )) func validateCamelCase(
+        input: String,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .camelCase,
+            input: input,
+            expects: error
+        )
+    }
+
     @Test("validate not empty", arguments: zip(
         Input.inputsNotEmpty,
         Output.inputsNotEmpty
@@ -161,6 +217,34 @@ struct ValidateInputUseCaseTests {
             expects: error
         )
     }
+    
+    @Test("validate semantic version", arguments: zip(
+        Input.inputsSemanticVersion,
+        Output.inputsSemanticVersion
+    )) func validateSemanticVersion(
+        input: String?,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .semanticVersion,
+            input: input,
+            expects: error
+        )
+    }
+    
+    @Test("validate url", arguments: zip(
+        Input.inputsURL,
+        Output.inputsURL
+    )) func validateURL(
+        input: String?,
+        expects error: InputValidationError?
+    ) async throws {
+        try assertValidate(
+            rule: .url,
+            input: input,
+            expects: error
+        )
+    }
 #endif
     
 }
@@ -203,6 +287,8 @@ private extension ValidateInputUseCaseTests {
 // MARK: - Constants
 
 private extension Input {
+    /// A list of inputs to validate against a camel-case validation rule.
+    static let inputsCamelCase: [String] = ["SampleApp", "Sample4pp", "SampleApp1", "SampleApp🚀", "Sample App", "Sample-App", "Sample_App"]
     /// A list of inputs to validate against the not empty validation rule.
     static let inputsNotEmpty: [String] = ["Something", .empty]
     /// A list of inputs to validate against the not nil validation rule.
@@ -213,9 +299,15 @@ private extension Input {
     static let inputsSecureConsumerSecret: [String] = ["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoO", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQ", "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9"]
     /// A list of inputs to validate against the secure (user token) validation rule.
     static let inputsSecureUserToken: [String] = ["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStT", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsS", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuU", "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9qQrRs5t7"]
+    /// A list of inputs to validate against the semantic version validation rule.
+    static let inputsSemanticVersion: [String] = ["0.0.4","1.2.3","10.20.30","1.1.2-prerelease+meta","1.1.2+meta","1.1.2+meta-valid","1.0.0-alpha","1.0.0-beta","1.0.0-alpha.beta","1.0.0-alpha.beta.1","1.0.0-alpha.1","1.0.0-alpha0.valid","1.0.0-alpha.0valid","1.0.0-alpha-a.b-c-somethinglong+build.1-aef.1-its-okay","1.0.0-rc.1+build.1","2.0.0-rc.1+build.123","1.2.3-beta","10.2.3-DEV-SNAPSHOT","1.2.3-SNAPSHOT-123","1.0.0","2.0.0","1.1.7","2.0.0+build.1848","2.0.1-alpha.1227","1.0.0-alpha+beta","1.2.3----RC-SNAPSHOT.12.9.1--.12+788","1.2.3----R-S.12.9.1--.12+meta","1.2.3----RC-SNAPSHOT.12.9.1--.12","1.0.0+0.build.1-rc.10000aaa-kk-0.1","99999999999999999999999.999999999999999999.99999999999999999","1.0.0-0A.is.legal","1","1.2","1.2.3-0123","1.2.3-0123.0123","1.1.2+.123","+invalid","-invalid","-invalid+invalid","-invalid.01","alpha","alpha.beta","alpha.beta.1","alpha.1","alpha+beta","alpha_beta","alpha.","alpha..","beta","1.0.0-alpha_beta","-alpha.","1.0.0-alpha..","1.0.0-alpha..1","1.0.0-alpha...1","1.0.0-alpha....1","1.0.0-alpha.....1","1.0.0-alpha......1","1.0.0-alpha.......1","01.1.1","1.01.1","1.1.01","1.2","1.2.3.DEV","1.2-SNAPSHOT","1.2.31.2.3----RC-SNAPSHOT.12.09.1--..12+788","1.2-RC-SNAPSHOT","-1.0.3-gamma+b7718","+justmeta","9.8.7+meta+meta","9.8.7-whatever+meta+meta","99999999999999999999999.999999999999999999.99999999999999999----RC-SNAPSHOT.12.09.1--------------------------------..12"]
+    /// A list of inputs to validate against the URL validation rule.
+    static let inputsURL: [String] = ["https://www.google.com", "http://www.google.com", "https://google.com/q=search", "http://google.com/q=search", "3333-768-0948", "1133.168.0248", "7678*999-8978", "httpq://google.com/q=search", "www.google.com", "www.google.com/?search=qppoao", "www . google.com/?search=qppoao", "https : //google.com/q=search", "htt://www.google.com", "://www.google.com", .empty]
 }
 
 private extension Output {
+    /// A list of expected input validation errors to be thrown after validating inputs against the camel-case validation rule.
+    static let inputsCamelCase: [InputValidationError?] = [nil, nil, nil, .inputNotCamelCase, .inputNotCamelCase, .inputNotCamelCase, .inputNotCamelCase]
     /// A list of expected input validation errors to be thrown after validating inputs against the not empty validation rule.
     static let inputsNotEmpty: [InputValidationError?] = [nil, .inputIsEmpty]
     /// A list of expected input validation errors to be thrown after validating inputs against the not nil validation rule.
@@ -226,4 +318,8 @@ private extension Output {
     static let inputsSecureConsumerSecret: [InputValidationError?] = [nil, .inputNotConsumerSecret, .inputNotConsumerSecret, .inputNotConsumerSecret]
     /// A list of expected input validation errors to be thrown after validating inputs against the secure (user token) validation rule.
     static let inputsSecureUserToken: [InputValidationError?] = [nil, .inputNotUserToken, .inputNotUserToken, .inputNotUserToken]
+    /// A list of expected input validation errors to be thrown after validating inputs against the semantic version validation rule.
+    static let inputsSemanticVersion: [InputValidationError?] = [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputNotSemanticVersion]
+    /// A list of expected input validation errors to be thrown after validating inputs against the URL validation rule.
+    static let inputsURL: [InputValidationError?] = [nil, nil, nil, nil, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL, .inputNotURL]
 }

Tests/DiscogsService/Cases/Public/Middlewares/AuthMiddlewareTests.swift

@@ -15,7 +15,6 @@
 import struct Foundation.URL
 import struct Foundation.URLComponents
 import struct Foundation.URLQueryItem
-import struct HTTPTypes.HTTPField
 import struct HTTPTypes.HTTPFields
 import struct HTTPTypes.HTTPRequest
 import struct HTTPTypes.HTTPResponse
@@ -28,6 +27,7 @@ import Testing
 struct AuthMiddlewareTests {
     
     // MARK: Initializers tests
+
 #if swift(>=6.2)
     @Test(arguments: Input.authMethods)
     func `initialize`(
@@ -273,11 +273,11 @@ private extension AuthMiddlewareTests {
         }
     }
 
-    /// Asserts the error throwing (if justified) during the initialization of the middleware.
+    /// Asserts the error throwing (if justified) during the initialization of a middleware.
     /// - Parameters:
     ///   - authMethod: A representation of an authentication method.
     ///   - authTransport: A representation of an authentication transport.
-    ///   - error: An expected error of type ``InputValidationError`` during the initialization of the middleware.
+    ///   - error: An expected error of type ``InputValidationError`` during the initialization of a middleware.
     func assertInitThrows(
         authMethod: AuthMethod,
         authTransport: AuthTransport,
@@ -331,8 +331,8 @@ private extension AuthMiddlewareTests {
             try await middleware.intercept(
                 request,
                 body: nil,
-                baseURL: .baseURL,
-                operationID: .operationId
+                baseURL: .Sample.baseURL,
+                operationID: .Sample.operationId
             ) { request, _, _ in
                 // THEN
                 switch (authMethod, authTransport) {
@@ -430,31 +430,6 @@ private extension AuthMiddlewareTests {
     
 }
 
-private extension HTTPRequest {
-    
-    // MARK: Initializers
-    
-    /// Initializes a HTTP request conveniently.
-    /// - Parameters:
-    ///   - method: A request method.
-    ///   - path: A value of the “:path” pseudo header field.
-    ///   - headerFields: A dictionary of request header fields.
-    init(
-        method: HTTPRequest.Method = .get,
-        path: String?,
-        headerFields: HTTPFields = [:]
-    ) {
-        self.init(
-            method: method,
-            scheme: nil,
-            authority: nil,
-            path: path,
-            headerFields: headerFields
-        )
-    }
-    
-}
-
 // MARK: - Constants
 
 private extension Input {
@@ -464,7 +439,7 @@ private extension Input {
         .user(token: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStT"),
         .none
     ]
-    /// A list of authentication methods to tests for the initialization throw test cases.
+    /// A list of authentication methods to use in the initialization throw test cases.
     static let authMethodsThrows: [AuthMethod] = authMethods + [
         .consumer(key: .empty, secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
         .consumer(key: "aAbBcCdDeEfFgGhHiI", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
@@ -487,13 +462,3 @@ private extension Output {
     /// A list of expected boolean flags coming from the should authenticate test cases.
     static let authMethodsShouldAuthenticate: [Bool] = [true, true, false]
 }
-
-private extension String {
-    /// An operation ID sample.
-    static let operationId = "SomeOperationId"
-}
-
-private extension URL {
-    /// A base URL sample.
-    static let baseURL = URL(string: "https://sample.domain.com")!
-}

Tests/DiscogsService/Cases/Public/Middlewares/UserAgentMiddlewareTests.swift

@@ -12,14 +12,215 @@
 //
 // ===----------------------------------------------------------------------===
 
-import DiscogsService
+import struct HTTPTypes.HTTPField
+import struct HTTPTypes.HTTPFields
+import struct HTTPTypes.HTTPRequest
+
 import Testing
 
+@testable import DiscogsService
+
 @Suite("User Agent Middleware", .tags(.middleware))
 struct UserAgentMiddlewareTests {
-
-//    @Test func <#test function name#>() async throws {
-//        // Write your test here and use APIs like `#expect(...)` to check expected conditions.
-//    }
-
+    
+    // MARK: Initializers tests
+    
+#if swift(>=6.2)
+    @Test(arguments: Input.userAgents)
+    func `initialize`(
+        product: Product
+    ) throws {
+        try assertInit(product: product)
+    }
+    
+    @Test(arguments: zip(
+        Input.userAgentsThrows,
+        Output.userAgentsThrows
+    ))
+    func `initialize throws`(
+        product: Product,
+        expect error: InputValidationError?
+    ) {
+        assertInitThrows(
+            product: product,
+            expects: error
+        )
+    }
+#else
+    @Test("initialize", arguments: Input.userAgents)
+    func initialize(
+        product: Product
+    ) throws {
+        try assertInit(product: product)
+    }
+    
+    @Test("initialize throws", arguments: zip(
+        Input.userAgentsThrows,
+        Output.userAgentsThrows
+    ))
+    func initializeThrows(
+        product: Product,
+        expect error: InputValidationError?
+    ) {
+        assertInitThrows(
+            product: product,
+            expects: error
+        )
+    }
+#endif
+    
+    // MARK: Functions tests
+    
+#if swift(>=6.2)
+    @Test(arguments: Input.userAgents)
+    func `intercept with user agent on headers`(
+        product: Product
+    ) async throws {
+        try await assertIntercept(product: product)
+    }
+    
+    @Test(arguments: Input.userAgents)
+    func `intercept with user agent on headers when headers are populated`(
+        product: Product
+    ) async throws {
+        try await assertIntercept(
+            product: product,
+            headerFields: [.accept: "*/*"]
+        )
+    }
+#else
+    @Test("intercept with user agent on headers", arguments: Input.userAgents)
+    func intercept_withUserAgentOnHeaders(
+        product: Product
+    ) async throws {
+        try await assertIntercept(product: product)
+    }
+    
+    @Test("intercept with user agent on headers when headers are populated", arguments: Input.userAgents)
+    func intercept_withUserAgentOnHeaders_whenHeadersPopulated(
+        product: Product
+    ) async throws {
+        try await assertIntercept(
+            product: product,
+            headerFields: [.accept: "*/*"]
+        )
+    }
+#endif
+    
+}
+
+// MARK: - Assertions
+
+private extension UserAgentMiddlewareTests {
+    
+    // MARK: Functions
+    
+    /// Asserts the initialization of the middleware , especially the assignments of its properties.
+    /// - Parameter product: A product to initialize a middleware.
+    /// - Throws: an error of type ``InputValidationError`` in case of an unexpected error occurs while running test cases.
+    func assertInit(
+        product: Product
+    ) throws {
+        // GIVEN
+        // WHEN
+        let middleware = try UserAgentMiddleware(product: product)
+        
+        // THEN
+        #expect(middleware.agentField == .init(
+            name: .userAgent,
+            value: "\(product.name)/\(product.version) +\(product.url)"
+        ))
+    }
+    
+    /// Asserts the error throwing (if justified) during the initialization of the middleware.
+    /// - Parameters:
+    ///   - product: A product to initialize a middleware.
+    ///   - error: An expected error of type ``InputValidationError`` during the initialization of a middleware.
+    func assertInitThrows(
+        product: Product,
+        expects error: InputValidationError?
+    ) {
+        // GIVEN
+        // WHEN
+        // THEN
+        if let error {
+            #expect(throws: error) {
+                try UserAgentMiddleware(product: product)
+            }
+        } else {
+            #expect(throws: Never.self) {
+                try UserAgentMiddleware(product: product)
+            }
+        }
+    }
+    
+    /// Asserts the interception of a request to add the user agent in its header.
+    /// - Parameters:
+    ///   - product: A product to initialize a middleware.
+    ///   - path: A URI path for a request.
+    ///   - headerFields: A set of header fields for a request.
+    func assertIntercept(
+        product: Product,
+        path: String? = nil,
+        headerFields: HTTPFields = [:]
+    ) async throws {
+        // GIVEN
+        let middleware = try UserAgentMiddleware(product: product)
+        let request = HTTPRequest(
+            path: path,
+            headerFields: headerFields
+        )
+
+        // WHEN
+        _ = try await confirmation { confirmation in
+            try await middleware.intercept(
+                request,
+                body: nil,
+                baseURL: .Sample.baseURL,
+                operationID: .Sample.operationId
+            ) { request, _, _ in
+                // THEN
+                #expect(request.path == path)
+                #expect(request.headerFields != headerFields)
+                #expect(request.headerFields.count == headerFields.count + 1)
+                #expect(request.headerFields.contains(where: { $0.name == .userAgent }))
+                
+                confirmation()
+                
+                return (.init(status: .ok) , nil)
+            }
+        }
+    }
+    
+}
+
+// MARK: - Constants
+
+private extension Input {
+    /// A list of products to successfully initialize user agent middleware instances.
+    static let userAgents: [Product] = [
+        .init(name: "SomeApp", version: "0.0.1", url: "http://www.some.app"),
+        .init(name: "SomeOther4pp", version: "1.2.3-b1", url: "https://some-other.app"),
+        .init(name: "Yet4notherApp", version: "0.8.8+alpha", url: "https://yet.another.app")
+    ]
+    /// A list of products to use in the initialization throw test cases.
+    static let userAgentsThrows: [Product] = userAgents + [
+        .init(name: "Some App", version: "0.0.1", url: "http://www.some.app"),
+        .init(name: "Some-App", version: "0.0.1", url: "http://www.some.app"),
+        .init(name: .empty, version: "0.0.1", url: "http://www.some.app"),
+        .init(name: "SomeApp", version: "v0.0.1", url: "http://www.some.app"),
+        .init(name: "SomeApp", version: "0.1", url: "http://www.some.app"),
+        .init(name: "SomeApp", version: .empty, url: "http://www.some.app"),
+        .init(name: "SomeApp", version: "0.0.1", url: "www.some.app"),
+        .init(name: "SomeApp", version: "0.0.1", url: "some.app"),
+        .init(name: "SomeApp", version: "0.0.1", url: .empty),
+        .init(name: "Some App", version: "v0.0.1", url: "www.some.app"),
+        .init(name: "SomeApp", version: "v0.0.1", url: "www.some.app"),
+        .init(name: "Some App", version: "0.0.1", url: "www.some.app"),
+    ]
+}
+
+private extension Output {
+    /// A list of expected input validation errors (if thrown) coming from the initialization throw test cases.
+    static let userAgentsThrows: [InputValidationError?] = [nil, nil, nil, .inputNotCamelCase, .inputNotCamelCase, .inputIsEmpty, .inputNotSemanticVersion, .inputNotSemanticVersion, .inputIsEmpty, .inputNotURL, .inputNotURL, .inputIsEmpty, .inputNotCamelCase,  .inputNotSemanticVersion, .inputNotCamelCase]
 }

Tests/DiscogsService/Types/Extensions/HTTPRequests+Inits.swift

@@ -0,0 +1,41 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+import struct HTTPTypes.HTTPFields
+import struct HTTPTypes.HTTPRequest
+
+extension HTTPRequest {
+    
+    // MARK: Initializers
+    
+    /// Initializes a HTTP request conveniently.
+    /// - Parameters:
+    ///   - method: A request method.
+    ///   - path: A value of the “:path” pseudo header field.
+    ///   - headerFields: A dictionary of request header fields.
+    init(
+        method: HTTPRequest.Method = .get,
+        path: String?,
+        headerFields: HTTPFields = [:]
+    ) {
+        self.init(
+            method: method,
+            scheme: nil,
+            authority: nil,
+            path: path,
+            headerFields: headerFields
+        )
+    }
+    
+}

Tests/DiscogsService/Types/Extensions/Tag+Customs.swift

@@ -18,6 +18,9 @@ extension Tag {
     
     // MARK: Constants
     
+    /// A tag that indicates tests for a type extension.
+    @Tag static var `extension`: Self
+    
     /// A tag that indicates tests for a middleware type.
     @Tag static var middleware: Self
     

Tests/DiscogsService/Types/Samples/String+Samples.swift

@@ -0,0 +1,21 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+extension String {
+    /// A namespace assigned for string samples on test cases.
+    enum Sample {
+        /// An operation ID sample.
+        static let operationId = "SomeOperationId"
+    }
+}

Tests/DiscogsService/Types/Samples/URL+Samples.swift

@@ -0,0 +1,23 @@
+// ===----------------------------------------------------------------------===
+//
+// This source file is part of the DiscogsService open source project
+//
+// Copyright (c) 2025 Röck+Cöde VoF. and the DiscogsService project authors
+// Licensed under Apache license v2.0
+//
+// See LICENSE for license information
+// See CONTRIBUTORS for the list of DiscogsService project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===
+
+import Foundation
+
+extension URL {
+    /// A namespace assigned for URL samples on test cases.
+    enum Sample {
+        /// A base URL sample.
+        static let baseURL = URL(string: "https://sample.domain.com")!
+    }
+}

docs/data/documentation/discogsservice/authmethod/!=(_:_:).json

@@ -1 +1 @@
-{"variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/!=(_:_:)"],"traits":[{"interfaceLanguage":"swift"}]}],"primaryContentSections":[{"declarations":[{"tokens":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"lhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"rhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","preciseIdentifier":"s:Sb","kind":"typeIdentifier"}],"platforms":["macOS"],"languages":["swift"]}],"kind":"declarations"},{"kind":"parameters","parameters":[{"name":"lhs","content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"A value to compare."}]}]},{"name":"rhs","content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Another value to compare."}]}]}]},{"content":[{"level":2,"anchor":"discussion","type":"heading","text":"Discussion"},{"type":"paragraph","inlineContent":[{"text":"Inequality is the inverse of equality. For any values ","type":"text"},{"type":"codeVoice","code":"a"},{"text":" and ","type":"text"},{"type":"codeVoice","code":"b"},{"text":", ","type":"text"},{"type":"codeVoice","code":"a != b"},{"text":" ","type":"text"},{"text":"implies that ","type":"text"},{"type":"codeVoice","code":"a == b"},{"text":" is ","type":"text"},{"type":"codeVoice","code":"false"},{"text":".","type":"text"}]},{"type":"paragraph","inlineContent":[{"text":"This is the default implementation of the not-equal-to operator (","type":"text"},{"type":"codeVoice","code":"!="},{"text":")","type":"text"},{"text":" ","type":"text"},{"text":"for any type that conforms to ","type":"text"},{"type":"codeVoice","code":"Equatable"},{"text":".","type":"text"}]}],"kind":"content"}],"kind":"symbol","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)"},"sections":[],"metadata":{"role":"symbol","extendedModule":"Swift","externalID":"s:SQsE2neoiySbx_xtFZ::SYNTHESIZED::s:14DiscogsService10AuthMethodO","modules":[{"name":"DiscogsService","relatedModules":["Swift"]}],"roleHeading":"Operator","title":"!=(_:_:)","symbolKind":"op","fragments":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"preciseIdentifier":"s:Sb","kind":"typeIdentifier","text":"Bool"}]},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"schemaVersion":{"major":0,"minor":3,"patch":0},"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMethod/!=(_:_:)":{"role":"symbol","type":"topic","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)","url":"\/documentation\/discogsservice\/authmethod\/!=(_:_:)","title":"!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}]},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","url":"\/documentation\/discogsservice\/authmethod","navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}]}}}
+{"variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/!=(_:_:)"],"traits":[{"interfaceLanguage":"swift"}]}],"primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"lhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"rhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"preciseIdentifier":"s:Sb","text":"Bool","kind":"typeIdentifier"}],"platforms":["macOS"],"languages":["swift"]}]},{"parameters":[{"content":[{"inlineContent":[{"text":"A value to compare.","type":"text"}],"type":"paragraph"}],"name":"lhs"},{"content":[{"inlineContent":[{"text":"Another value to compare.","type":"text"}],"type":"paragraph"}],"name":"rhs"}],"kind":"parameters"},{"kind":"content","content":[{"level":2,"type":"heading","anchor":"discussion","text":"Discussion"},{"inlineContent":[{"text":"Inequality is the inverse of equality. For any values ","type":"text"},{"type":"codeVoice","code":"a"},{"text":" and ","type":"text"},{"type":"codeVoice","code":"b"},{"text":", ","type":"text"},{"type":"codeVoice","code":"a != b"},{"text":" ","type":"text"},{"text":"implies that ","type":"text"},{"type":"codeVoice","code":"a == b"},{"text":" is ","type":"text"},{"type":"codeVoice","code":"false"},{"text":".","type":"text"}],"type":"paragraph"},{"inlineContent":[{"text":"This is the default implementation of the not-equal-to operator (","type":"text"},{"type":"codeVoice","code":"!="},{"text":")","type":"text"},{"text":" ","type":"text"},{"text":"for any type that conforms to ","type":"text"},{"type":"codeVoice","code":"Equatable"},{"text":".","type":"text"}],"type":"paragraph"}]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"kind":"symbol","schemaVersion":{"minor":3,"patch":0,"major":0},"sections":[],"abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)"},"metadata":{"modules":[{"name":"DiscogsService","relatedModules":["Swift"]}],"role":"symbol","title":"!=(_:_:)","extendedModule":"Swift","externalID":"s:SQsE2neoiySbx_xtFZ::SYNTHESIZED::s:14DiscogsService10AuthMethodO","symbolKind":"op","roleHeading":"Operator","fragments":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"kind":"typeIdentifier","preciseIdentifier":"s:Sb","text":"Bool"}]},"references":{"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/!=(_:_:)":{"url":"\/documentation\/discogsservice\/authmethod\/!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}],"abstract":[{"text":"Returns a Boolean value indicating whether two values are not equal.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)","title":"!=(_:_:)","type":"topic","kind":"symbol","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"type":"topic","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","url":"\/documentation\/discogsservice\/authmethod"}}}

docs/data/documentation/discogsservice/authmethod/consumer(key:secret:).json

@@ -1 +1 @@
-{"kind":"symbol","hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"abstract":[{"text":"A consumer key and secret that allows access to endpoints that requires authentication.","type":"text"}],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authmethod\/consumer(key:secret:)"]}],"primaryContentSections":[{"kind":"declarations","declarations":[{"platforms":["macOS"],"languages":["swift"],"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","preciseIdentifier":"s:SS","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","preciseIdentifier":"s:SS","kind":"typeIdentifier"},{"text":")","kind":"text"}]}]}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/consumer(key:secret:)","interfaceLanguage":"swift"},"schemaVersion":{"minor":3,"major":0,"patch":0},"metadata":{"role":"symbol","symbolKind":"case","title":"AuthMethod.consumer(key:secret:)","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","preciseIdentifier":"s:SS","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","preciseIdentifier":"s:SS","kind":"typeIdentifier"},{"text":")","kind":"text"}],"externalID":"s:14DiscogsService10AuthMethodO8consumeryACSS_SStcACmF","roleHeading":"Case","modules":[{"name":"DiscogsService"}]},"sections":[],"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","url":"\/documentation\/discogsservice\/authmethod","navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/consumer(key:secret:)":{"fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":")","kind":"text"}],"role":"symbol","url":"\/documentation\/discogsservice\/authmethod\/consumer(key:secret:)","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/consumer(key:secret:)","abstract":[{"type":"text","text":"A consumer key and secret that allows access to endpoints that requires authentication."}],"title":"AuthMethod.consumer(key:secret:)","type":"topic","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"}}}
+{"metadata":{"modules":[{"name":"DiscogsService"}],"roleHeading":"Case","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":")","kind":"text"}],"symbolKind":"case","externalID":"s:14DiscogsService10AuthMethodO8consumeryACSS_SStcACmF","title":"AuthMethod.consumer(key:secret:)","role":"symbol"},"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/consumer(key:secret:)"},"abstract":[{"type":"text","text":"A consumer key and secret that allows access to endpoints that requires authentication."}],"variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/consumer(key:secret:)"],"traits":[{"interfaceLanguage":"swift"}]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"schemaVersion":{"major":0,"patch":0,"minor":3},"sections":[],"kind":"symbol","primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":")","kind":"text"}],"platforms":["macOS"],"languages":["swift"]}]}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"type":"topic","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","url":"\/documentation\/discogsservice\/authmethod"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/consumer(key:secret:)":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/consumer(key:secret:)","abstract":[{"text":"A consumer key and secret that allows access to endpoints that requires authentication.","type":"text"}],"type":"topic","kind":"symbol","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"consumer","kind":"identifier"},{"text":"(","kind":"text"},{"text":"key","kind":"externalParam"},{"text":": ","kind":"text"},{"preciseIdentifier":"s:SS","text":"String","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"secret","kind":"externalParam"},{"text":": ","kind":"text"},{"preciseIdentifier":"s:SS","text":"String","kind":"typeIdentifier"},{"text":")","kind":"text"}],"title":"AuthMethod.consumer(key:secret:)","url":"\/documentation\/discogsservice\/authmethod\/consumer(key:secret:)"}}}

docs/data/documentation/discogsservice/authmethod/equatable-implementations.json

@@ -1 +1 @@
-{"metadata":{"modules":[{"name":"DiscogsService"}],"roleHeading":"API Collection","role":"collectionGroup","title":"Equatable Implementations"},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/Equatable-Implementations","interfaceLanguage":"swift"},"schemaVersion":{"minor":3,"patch":0,"major":0},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authmethod\/equatable-implementations"]}],"sections":[],"topicSections":[{"generated":true,"anchor":"Operators","title":"Operators","identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)"]}],"kind":"article","references":{"doc://DiscogsService/documentation/DiscogsService/AuthMethod/!=(_:_:)":{"role":"symbol","type":"topic","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)","url":"\/documentation\/discogsservice\/authmethod\/!=(_:_:)","title":"!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}]},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","url":"\/documentation\/discogsservice\/authmethod","navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}]}}}
+{"schemaVersion":{"patch":0,"minor":3,"major":0},"metadata":{"modules":[{"name":"DiscogsService"}],"title":"Equatable Implementations","role":"collectionGroup","roleHeading":"API Collection"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"sections":[],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/Equatable-Implementations"},"topicSections":[{"title":"Operators","identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)"],"generated":true,"anchor":"Operators"}],"kind":"article","variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/equatable-implementations"],"traits":[{"interfaceLanguage":"swift"}]}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"type":"topic","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","url":"\/documentation\/discogsservice\/authmethod"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/!=(_:_:)":{"url":"\/documentation\/discogsservice\/authmethod\/!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}],"abstract":[{"text":"Returns a Boolean value indicating whether two values are not equal.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/!=(_:_:)","title":"!=(_:_:)","type":"topic","kind":"symbol","role":"symbol"}}}

docs/data/documentation/discogsservice/authmethod/none.json

@@ -1 +1 @@
-{"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/none"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authmethod\/none"]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"schemaVersion":{"minor":3,"patch":0,"major":0},"metadata":{"role":"symbol","roleHeading":"Case","title":"AuthMethod.none","symbolKind":"case","fragments":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"none"}],"modules":[{"name":"DiscogsService"}],"externalID":"s:14DiscogsService10AuthMethodO4noneyA2CmF"},"abstract":[{"text":"No authentication method defined.","type":"text"}],"kind":"symbol","primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"none"}],"platforms":["macOS"],"languages":["swift"]}]}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","url":"\/documentation\/discogsservice\/authmethod","navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/none":{"fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"none","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/authmethod\/none","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/none","abstract":[{"type":"text","text":"No authentication method defined."}],"title":"AuthMethod.none","type":"topic","kind":"symbol"}}}
+{"metadata":{"externalID":"s:14DiscogsService10AuthMethodO4noneyA2CmF","symbolKind":"case","roleHeading":"Case","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"none","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"title":"AuthMethod.none","role":"symbol"},"kind":"symbol","hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"none","kind":"identifier"}],"languages":["swift"],"platforms":["macOS"]}]}],"abstract":[{"type":"text","text":"No authentication method defined."}],"sections":[],"schemaVersion":{"minor":3,"patch":0,"major":0},"variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/none"],"traits":[{"interfaceLanguage":"swift"}]}],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/none"},"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMethod/none":{"abstract":[{"text":"No authentication method defined.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/none","type":"topic","url":"\/documentation\/discogsservice\/authmethod\/none","kind":"symbol","role":"symbol","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"none","kind":"identifier"}],"title":"AuthMethod.none"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"type":"topic","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","url":"\/documentation\/discogsservice\/authmethod"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}

docs/data/documentation/discogsservice/authmethod/user(token:).json

@@ -1 +1 @@
-{"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/user(token:)"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authmethod\/user(token:)"]}],"abstract":[{"type":"text","text":"A user token that allows access to its own account information."}],"schemaVersion":{"major":0,"minor":3,"patch":0},"primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"user"},{"kind":"text","text":"("},{"kind":"externalParam","text":"token"},{"kind":"text","text":": "},{"preciseIdentifier":"s:SS","kind":"typeIdentifier","text":"String"},{"kind":"text","text":")"}],"platforms":["macOS"],"languages":["swift"]}]}],"metadata":{"role":"symbol","symbolKind":"case","roleHeading":"Case","modules":[{"name":"DiscogsService"}],"externalID":"s:14DiscogsService10AuthMethodO4useryACSS_tcACmF","fragments":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"user"},{"kind":"text","text":"("},{"kind":"externalParam","text":"token"},{"kind":"text","text":": "},{"kind":"typeIdentifier","preciseIdentifier":"s:SS","text":"String"},{"kind":"text","text":")"}],"title":"AuthMethod.user(token:)"},"kind":"symbol","references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod/user(token:)":{"fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"user","kind":"identifier"},{"text":"(","kind":"text"},{"text":"token","kind":"externalParam"},{"text":": ","kind":"text"},{"text":"String","kind":"typeIdentifier","preciseIdentifier":"s:SS"},{"text":")","kind":"text"}],"role":"symbol","url":"\/documentation\/discogsservice\/authmethod\/user(token:)","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/user(token:)","abstract":[{"type":"text","text":"A user token that allows access to its own account information."}],"title":"AuthMethod.user(token:)","type":"topic","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","url":"\/documentation\/discogsservice\/authmethod","navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}]}}}
+{"abstract":[{"type":"text","text":"A user token that allows access to its own account information."}],"primaryContentSections":[{"kind":"declarations","declarations":[{"platforms":["macOS"],"languages":["swift"],"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"kind":"identifier","text":"user"},{"text":"(","kind":"text"},{"kind":"externalParam","text":"token"},{"text":": ","kind":"text"},{"kind":"typeIdentifier","preciseIdentifier":"s:SS","text":"String"},{"text":")","kind":"text"}]}]}],"kind":"symbol","metadata":{"roleHeading":"Case","role":"symbol","externalID":"s:14DiscogsService10AuthMethodO4useryACSS_tcACmF","title":"AuthMethod.user(token:)","fragments":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"user"},{"kind":"text","text":"("},{"kind":"externalParam","text":"token"},{"kind":"text","text":": "},{"preciseIdentifier":"s:SS","text":"String","kind":"typeIdentifier"},{"kind":"text","text":")"}],"symbolKind":"case","modules":[{"name":"DiscogsService"}]},"sections":[],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod"]]},"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/user(token:)"},"variants":[{"paths":["\/documentation\/discogsservice\/authmethod\/user(token:)"],"traits":[{"interfaceLanguage":"swift"}]}],"schemaVersion":{"minor":3,"patch":0,"major":0},"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMethod/user(token:)":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod\/user(token:)","abstract":[{"text":"A user token that allows access to its own account information.","type":"text"}],"type":"topic","kind":"symbol","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"user","kind":"identifier"},{"text":"(","kind":"text"},{"text":"token","kind":"externalParam"},{"text":": ","kind":"text"},{"preciseIdentifier":"s:SS","text":"String","kind":"typeIdentifier"},{"text":")","kind":"text"}],"title":"AuthMethod.user(token:)","url":"\/documentation\/discogsservice\/authmethod\/user(token:)"},"doc://DiscogsService/documentation/DiscogsService/AuthMethod":{"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMethod","abstract":[{"text":"A representation of the available authentication methods at the Discogs service.","type":"text"}],"navigatorTitle":[{"text":"AuthMethod","kind":"identifier"}],"type":"topic","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthMethod","kind":"identifier"}],"title":"AuthMethod","url":"\/documentation\/discogsservice\/authmethod"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}

docs/data/documentation/discogsservice/authmiddleware/clientmiddleware-implementations.json

@@ -1 +1 @@
-{"kind":"article","hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware"]]},"variants":[{"paths":["\/documentation\/discogsservice\/authmiddleware\/clientmiddleware-implementations"],"traits":[{"interfaceLanguage":"swift"}]}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/ClientMiddleware-Implementations","interfaceLanguage":"swift"},"schemaVersion":{"patch":0,"minor":3,"major":0},"sections":[],"metadata":{"role":"collectionGroup","modules":[{"name":"DiscogsService"}],"title":"ClientMiddleware Implementations","roleHeading":"API Collection"},"topicSections":[{"title":"Instance Methods","anchor":"Instance-Methods","generated":true,"identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/intercept(_:body:baseURL:operationID:next:)"]}],"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMiddleware":{"fragments":[{"kind":"keyword","text":"struct"},{"kind":"text","text":" "},{"kind":"identifier","text":"AuthMiddleware"}],"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"AuthMiddleware"}],"url":"\/documentation\/discogsservice\/authmiddleware","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware","abstract":[{"type":"text","text":"A middleware that attaches any defined authentication credentials into the requests for the service."}],"title":"AuthMiddleware","kind":"symbol","type":"topic"},"doc://DiscogsService/documentation/DiscogsService/AuthMiddleware/intercept(_:body:baseURL:operationID:next:)":{"fragments":[{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"intercept"},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"HTTPRequest","preciseIdentifier":"s:9HTTPTypes11HTTPRequestV"},{"kind":"text","text":", "},{"kind":"externalParam","text":"body"},{"kind":"text","text":": "},{"kind":"typeIdentifier","text":"HTTPBody","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC"},{"kind":"text","text":"?, "},{"kind":"externalParam","text":"baseURL"},{"kind":"text","text":": "},{"kind":"typeIdentifier","text":"URL","preciseIdentifier":"s:10Foundation3URLV"},{"kind":"text","text":", "},{"kind":"externalParam","text":"operationID"},{"kind":"text","text":": "},{"kind":"typeIdentifier","text":"String","preciseIdentifier":"s:SS"},{"kind":"text","text":", "},{"kind":"externalParam","text":"next"},{"kind":"text","text":": ("},{"kind":"typeIdentifier","text":"HTTPRequest","preciseIdentifier":"s:9HTTPTypes11HTTPRequestV"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"HTTPBody","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC"},{"kind":"text","text":"?, "},{"kind":"typeIdentifier","text":"URL","preciseIdentifier":"s:10Foundation3URLV"},{"kind":"text","text":") "},{"kind":"keyword","text":"async"},{"kind":"text","text":" "},{"kind":"keyword","text":"throws"},{"kind":"text","text":" -> ("},{"kind":"typeIdentifier","text":"HTTPResponse","preciseIdentifier":"s:9HTTPTypes12HTTPResponseV"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"HTTPBody","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC"},{"kind":"text","text":"?)) "},{"kind":"keyword","text":"async"},{"kind":"text","text":" "},{"kind":"keyword","text":"throws"},{"kind":"text","text":" -> ("},{"kind":"typeIdentifier","text":"HTTPResponse","preciseIdentifier":"s:9HTTPTypes12HTTPResponseV"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"HTTPBody","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC"},{"kind":"text","text":"?)"}],"role":"symbol","url":"\/documentation\/discogsservice\/authmiddleware\/intercept(_:body:baseurl:operationid:next:)","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/intercept(_:body:baseURL:operationID:next:)","abstract":[],"title":"intercept(_:body:baseURL:operationID:next:)","kind":"symbol","type":"topic"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"}}}
+{"metadata":{"modules":[{"name":"DiscogsService"}],"roleHeading":"API Collection","title":"ClientMiddleware Implementations","role":"collectionGroup"},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/ClientMiddleware-Implementations","interfaceLanguage":"swift"},"variants":[{"paths":["\/documentation\/discogsservice\/authmiddleware\/clientmiddleware-implementations"],"traits":[{"interfaceLanguage":"swift"}]}],"schemaVersion":{"major":0,"minor":3,"patch":0},"kind":"article","sections":[],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware"]]},"topicSections":[{"generated":true,"anchor":"Instance-Methods","title":"Instance Methods","identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/intercept(_:body:baseURL:operationID:next:)"]}],"references":{"doc://DiscogsService/documentation/DiscogsService/AuthMiddleware":{"abstract":[{"type":"text","text":"A middleware that attaches any defined authentication credentials into the requests to the service."}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware","type":"topic","kind":"symbol","url":"\/documentation\/discogsservice\/authmiddleware","role":"symbol","navigatorTitle":[{"kind":"identifier","text":"AuthMiddleware"}],"fragments":[{"kind":"keyword","text":"struct"},{"kind":"text","text":" "},{"kind":"identifier","text":"AuthMiddleware"}],"title":"AuthMiddleware"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthMiddleware/intercept(_:body:baseURL:operationID:next:)":{"type":"topic","title":"intercept(_:body:baseURL:operationID:next:)","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthMiddleware\/intercept(_:body:baseURL:operationID:next:)","abstract":[],"role":"symbol","url":"\/documentation\/discogsservice\/authmiddleware\/intercept(_:body:baseurl:operationid:next:)","fragments":[{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"intercept"},{"kind":"text","text":"("},{"kind":"typeIdentifier","preciseIdentifier":"s:9HTTPTypes11HTTPRequestV","text":"HTTPRequest"},{"kind":"text","text":", "},{"kind":"externalParam","text":"body"},{"kind":"text","text":": "},{"kind":"typeIdentifier","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC","text":"HTTPBody"},{"kind":"text","text":"?, "},{"kind":"externalParam","text":"baseURL"},{"kind":"text","text":": "},{"kind":"typeIdentifier","preciseIdentifier":"s:10Foundation3URLV","text":"URL"},{"kind":"text","text":", "},{"kind":"externalParam","text":"operationID"},{"kind":"text","text":": "},{"kind":"typeIdentifier","preciseIdentifier":"s:SS","text":"String"},{"kind":"text","text":", "},{"kind":"externalParam","text":"next"},{"kind":"text","text":": ("},{"kind":"typeIdentifier","preciseIdentifier":"s:9HTTPTypes11HTTPRequestV","text":"HTTPRequest"},{"kind":"text","text":", "},{"kind":"typeIdentifier","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC","text":"HTTPBody"},{"kind":"text","text":"?, "},{"kind":"typeIdentifier","preciseIdentifier":"s:10Foundation3URLV","text":"URL"},{"kind":"text","text":") "},{"kind":"keyword","text":"async"},{"kind":"text","text":" "},{"kind":"keyword","text":"throws"},{"kind":"text","text":" -> ("},{"kind":"typeIdentifier","preciseIdentifier":"s:9HTTPTypes12HTTPResponseV","text":"HTTPResponse"},{"kind":"text","text":", "},{"kind":"typeIdentifier","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC","text":"HTTPBody"},{"kind":"text","text":"?)) "},{"kind":"keyword","text":"async"},{"kind":"text","text":" "},{"kind":"keyword","text":"throws"},{"kind":"text","text":" -> ("},{"kind":"typeIdentifier","preciseIdentifier":"s:9HTTPTypes12HTTPResponseV","text":"HTTPResponse"},{"kind":"text","text":", "},{"kind":"typeIdentifier","preciseIdentifier":"s:14OpenAPIRuntime8HTTPBodyC","text":"HTTPBody"},{"kind":"text","text":"?)"}],"kind":"symbol"}}}

docs/data/documentation/discogsservice/authtransport/!=(_:_:).json

@@ -1 +1 @@
-{"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authtransport\/!=(_:_:)"]}],"primaryContentSections":[{"declarations":[{"tokens":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"internalParam","text":"lhs"},{"kind":"text","text":": "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"internalParam","text":"rhs"},{"kind":"text","text":": "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"preciseIdentifier":"s:Sb","kind":"typeIdentifier","text":"Bool"}],"platforms":["macOS"],"languages":["swift"]}],"kind":"declarations"},{"parameters":[{"name":"lhs","content":[{"inlineContent":[{"type":"text","text":"A value to compare."}],"type":"paragraph"}]},{"name":"rhs","content":[{"inlineContent":[{"type":"text","text":"Another value to compare."}],"type":"paragraph"}]}],"kind":"parameters"},{"content":[{"anchor":"discussion","level":2,"type":"heading","text":"Discussion"},{"inlineContent":[{"type":"text","text":"Inequality is the inverse of equality. For any values "},{"type":"codeVoice","code":"a"},{"type":"text","text":" and "},{"type":"codeVoice","code":"b"},{"type":"text","text":", "},{"type":"codeVoice","code":"a != b"},{"type":"text","text":" "},{"type":"text","text":"implies that "},{"type":"codeVoice","code":"a == b"},{"type":"text","text":" is "},{"type":"codeVoice","code":"false"},{"type":"text","text":"."}],"type":"paragraph"},{"inlineContent":[{"type":"text","text":"This is the default implementation of the not-equal-to operator ("},{"type":"codeVoice","code":"!="},{"type":"text","text":")"},{"type":"text","text":" "},{"type":"text","text":"for any type that conforms to "},{"type":"codeVoice","code":"Equatable"},{"type":"text","text":"."}],"type":"paragraph"}],"kind":"content"}],"metadata":{"roleHeading":"Operator","role":"symbol","externalID":"s:SQsE2neoiySbx_xtFZ::SYNTHESIZED::s:14DiscogsService13AuthTransportO","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"preciseIdentifier":"s:Sb","text":"Bool","kind":"typeIdentifier"}],"title":"!=(_:_:)","extendedModule":"Swift","modules":[{"relatedModules":["Swift"],"name":"DiscogsService"}],"symbolKind":"op"},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)","interfaceLanguage":"swift"},"schemaVersion":{"minor":3,"patch":0,"major":0},"sections":[],"kind":"symbol","abstract":[{"text":"Returns a Boolean value indicating whether two values are not equal.","type":"text"}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available transport options to send credentials in authenticated requests.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","url":"\/documentation\/discogsservice\/authtransport","navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"title":"AuthTransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/!=(_:_:)":{"kind":"symbol","role":"symbol","url":"\/documentation\/discogsservice\/authtransport\/!=(_:_:)","title":"!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}],"abstract":[{"text":"Returns a Boolean value indicating whether two values are not equal.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)","type":"topic"}}}
+{"kind":"symbol","identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"primaryContentSections":[{"declarations":[{"languages":["swift"],"tokens":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"lhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"rhs","kind":"internalParam"},{"text":": ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","preciseIdentifier":"s:Sb","kind":"typeIdentifier"}],"platforms":["macOS"]}],"kind":"declarations"},{"parameters":[{"name":"lhs","content":[{"inlineContent":[{"text":"A value to compare.","type":"text"}],"type":"paragraph"}]},{"name":"rhs","content":[{"inlineContent":[{"text":"Another value to compare.","type":"text"}],"type":"paragraph"}]}],"kind":"parameters"},{"content":[{"type":"heading","text":"Discussion","level":2,"anchor":"discussion"},{"type":"paragraph","inlineContent":[{"text":"Inequality is the inverse of equality. For any values ","type":"text"},{"code":"a","type":"codeVoice"},{"text":" and ","type":"text"},{"code":"b","type":"codeVoice"},{"text":", ","type":"text"},{"code":"a != b","type":"codeVoice"},{"text":" ","type":"text"},{"text":"implies that ","type":"text"},{"code":"a == b","type":"codeVoice"},{"text":" is ","type":"text"},{"code":"false","type":"codeVoice"},{"text":".","type":"text"}]},{"type":"paragraph","inlineContent":[{"text":"This is the default implementation of the not-equal-to operator (","type":"text"},{"code":"!=","type":"codeVoice"},{"text":")","type":"text"},{"text":" ","type":"text"},{"text":"for any type that conforms to ","type":"text"},{"code":"Equatable","type":"codeVoice"},{"text":".","type":"text"}]}],"kind":"content"}],"metadata":{"title":"!=(_:_:)","symbolKind":"op","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","preciseIdentifier":"s:Sb","kind":"typeIdentifier"}],"modules":[{"name":"DiscogsService","relatedModules":["Swift"]}],"role":"symbol","extendedModule":"Swift","roleHeading":"Operator","externalID":"s:SQsE2neoiySbx_xtFZ::SYNTHESIZED::s:14DiscogsService13AuthTransportO"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authtransport\/!=(_:_:)"]}],"schemaVersion":{"major":0,"minor":3,"patch":0},"references":{"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/!=(_:_:)":{"type":"topic","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"role":"symbol","url":"\/documentation\/discogsservice\/authtransport\/!=(_:_:)","fragments":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"preciseIdentifier":"s:Sb","kind":"typeIdentifier","text":"Bool"}],"title":"!=(_:_:)"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"url":"\/documentation\/discogsservice\/authtransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}],"navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"abstract":[{"type":"text","text":"A representation of the available transport options to send credentials in authenticated requests."}],"title":"AuthTransport","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","type":"topic","kind":"symbol","role":"symbol"}}}

docs/data/documentation/discogsservice/authtransport/equatable-implementations.json

@@ -1 +1 @@
-{"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"variants":[{"paths":["\/documentation\/discogsservice\/authtransport\/equatable-implementations"],"traits":[{"interfaceLanguage":"swift"}]}],"topicSections":[{"identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)"],"title":"Operators","anchor":"Operators","generated":true}],"kind":"article","identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/Equatable-Implementations"},"schemaVersion":{"minor":3,"major":0,"patch":0},"sections":[],"metadata":{"role":"collectionGroup","title":"Equatable Implementations","modules":[{"name":"DiscogsService"}],"roleHeading":"API Collection"},"references":{"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available transport options to send credentials in authenticated requests.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","url":"\/documentation\/discogsservice\/authtransport","navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"title":"AuthTransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/!=(_:_:)":{"kind":"symbol","role":"symbol","url":"\/documentation\/discogsservice\/authtransport\/!=(_:_:)","title":"!=(_:_:)","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}],"abstract":[{"text":"Returns a Boolean value indicating whether two values are not equal.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)","type":"topic"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"}}}
+{"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"metadata":{"title":"Equatable Implementations","role":"collectionGroup","modules":[{"name":"DiscogsService"}],"roleHeading":"API Collection"},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authtransport\/equatable-implementations"]}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/Equatable-Implementations","interfaceLanguage":"swift"},"topicSections":[{"title":"Operators","identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)"],"generated":true,"anchor":"Operators"}],"sections":[],"schemaVersion":{"major":0,"minor":3,"patch":0},"kind":"article","references":{"doc://DiscogsService/documentation/DiscogsService/AuthTransport/!=(_:_:)":{"type":"topic","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/!=(_:_:)","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"role":"symbol","url":"\/documentation\/discogsservice\/authtransport\/!=(_:_:)","fragments":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"preciseIdentifier":"s:Sb","kind":"typeIdentifier","text":"Bool"}],"title":"!=(_:_:)"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"url":"\/documentation\/discogsservice\/authtransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}],"navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"abstract":[{"type":"text","text":"A representation of the available transport options to send credentials in authenticated requests."}],"title":"AuthTransport","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","type":"topic","kind":"symbol","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}

docs/data/documentation/discogsservice/authtransport/onheader.json

@@ -1 +1 @@
-{"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onHeader"},"sections":[],"variants":[{"paths":["\/documentation\/discogsservice\/authtransport\/onheader"],"traits":[{"interfaceLanguage":"swift"}]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"schemaVersion":{"major":0,"patch":0,"minor":3},"metadata":{"role":"symbol","title":"AuthTransport.onHeader","roleHeading":"Case","symbolKind":"case","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"externalID":"s:14DiscogsService13AuthTransportO8onHeaderyA2CmF"},"abstract":[{"text":"Authentication credential are sent in a request as an ","type":"text"},{"code":"Authentication","type":"codeVoice"},{"text":" header.","type":"text"}],"kind":"symbol","primaryContentSections":[{"declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"platforms":["macOS"],"languages":["swift"]}],"kind":"declarations"},{"content":[{"level":2,"type":"heading","text":"Discussion","anchor":"discussion"},{"type":"paragraph","inlineContent":[{"type":"text","text":"This means that the header will be added to any existing header in a request, like this:"}]},{"code":["curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer\" -H \"Authorization: Discogs key=foo123, secret=bar456\"","curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer\" -H \"Authorization: Discogs token=abcxyz123456\""],"type":"codeListing","syntax":"bash"}],"kind":"content"}],"references":{"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available transport options to send credentials in authenticated requests.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","url":"\/documentation\/discogsservice\/authtransport","navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"title":"AuthTransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/onHeader":{"title":"AuthTransport.onHeader","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onHeader","role":"symbol","kind":"symbol","type":"topic","url":"\/documentation\/discogsservice\/authtransport\/onheader","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"abstract":[{"text":"Authentication credential are sent in a request as an ","type":"text"},{"code":"Authentication","type":"codeVoice"},{"text":" header.","type":"text"}]}}}
+{"kind":"symbol","identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onHeader","interfaceLanguage":"swift"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"abstract":[{"text":"Authentication credential are sent in a request as an ","type":"text"},{"code":"Authentication","type":"codeVoice"},{"text":" header.","type":"text"}],"primaryContentSections":[{"declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"languages":["swift"],"platforms":["macOS"]}],"kind":"declarations"},{"content":[{"text":"Discussion","level":2,"type":"heading","anchor":"discussion"},{"inlineContent":[{"type":"text","text":"This means that the header will be added to any existing header in a request, like this:"}],"type":"paragraph"},{"type":"codeListing","syntax":"bash","code":["curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer\" -H \"Authorization: Discogs key=foo123, secret=bar456\"","curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer\" -H \"Authorization: Discogs token=abcxyz123456\""]}],"kind":"content"}],"metadata":{"title":"AuthTransport.onHeader","symbolKind":"case","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"role":"symbol","externalID":"s:14DiscogsService13AuthTransportO8onHeaderyA2CmF","roleHeading":"Case"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authtransport\/onheader"]}],"schemaVersion":{"minor":3,"patch":0,"major":0},"references":{"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"url":"\/documentation\/discogsservice\/authtransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}],"navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"abstract":[{"type":"text","text":"A representation of the available transport options to send credentials in authenticated requests."}],"title":"AuthTransport","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","type":"topic","kind":"symbol","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/onHeader":{"url":"\/documentation\/discogsservice\/authtransport\/onheader","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onHeader","kind":"identifier"}],"abstract":[{"type":"text","text":"Authentication credential are sent in a request as an "},{"type":"codeVoice","code":"Authentication"},{"type":"text","text":" header."}],"title":"AuthTransport.onHeader","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onHeader","type":"topic","kind":"symbol","role":"symbol"}}}

docs/data/documentation/discogsservice/authtransport/onquery.json

@@ -1 +1 @@
-{"abstract":[{"text":"Authentication credential are sent in a request as parameters in the query string.","type":"text"}],"variants":[{"paths":["\/documentation\/discogsservice\/authtransport\/onquery"],"traits":[{"interfaceLanguage":"swift"}]}],"primaryContentSections":[{"declarations":[{"platforms":["macOS"],"languages":["swift"],"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onQuery","kind":"identifier"}]}],"kind":"declarations"},{"content":[{"text":"Discussion","level":2,"anchor":"discussion","type":"heading"},{"type":"paragraph","inlineContent":[{"text":"This means that the parameters will be injected into the query in a request, like this:","type":"text"}]},{"syntax":"bash","type":"codeListing","code":["curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer&key=foo123&secret=bar456\"","curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer&token=abcxyz123456\""]}],"kind":"content"}],"schemaVersion":{"major":0,"patch":0,"minor":3},"metadata":{"role":"symbol","roleHeading":"Case","symbolKind":"case","title":"AuthTransport.onQuery","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onQuery","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"externalID":"s:14DiscogsService13AuthTransportO7onQueryyA2CmF"},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onQuery","interfaceLanguage":"swift"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"kind":"symbol","sections":[],"references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"role":"symbol","type":"topic","abstract":[{"text":"A representation of the available transport options to send credentials in authenticated requests.","type":"text"}],"kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","url":"\/documentation\/discogsservice\/authtransport","navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"title":"AuthTransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}]},"doc://DiscogsService/documentation/DiscogsService/AuthTransport/onQuery":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onQuery","role":"symbol","title":"AuthTransport.onQuery","url":"\/documentation\/discogsservice\/authtransport\/onquery","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onQuery","kind":"identifier"}],"abstract":[{"text":"Authentication credential are sent in a request as parameters in the query string.","type":"text"}],"kind":"symbol","type":"topic"}}}
+{"schemaVersion":{"major":0,"minor":3,"patch":0},"metadata":{"symbolKind":"case","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onQuery","kind":"identifier"}],"externalID":"s:14DiscogsService13AuthTransportO7onQueryyA2CmF","modules":[{"name":"DiscogsService"}],"roleHeading":"Case","title":"AuthTransport.onQuery","role":"symbol"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport"]]},"sections":[],"abstract":[{"text":"Authentication credential are sent in a request as parameters in the query string.","type":"text"}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onQuery","interfaceLanguage":"swift"},"primaryContentSections":[{"kind":"declarations","declarations":[{"platforms":["macOS"],"languages":["swift"],"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"onQuery","kind":"identifier"}]}]},{"kind":"content","content":[{"anchor":"discussion","level":2,"text":"Discussion","type":"heading"},{"inlineContent":[{"text":"This means that the parameters will be injected into the query in a request, like this:","type":"text"}],"type":"paragraph"},{"code":["curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer&key=foo123&secret=bar456\"","curl \"https:\/\/api.discogs.com\/database\/search?q=Slayer&token=abcxyz123456\""],"syntax":"bash","type":"codeListing"}]}],"kind":"symbol","variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/authtransport\/onquery"]}],"references":{"doc://DiscogsService/documentation/DiscogsService/AuthTransport/onQuery":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport\/onQuery","abstract":[{"text":"Authentication credential are sent in a request as parameters in the query string.","type":"text"}],"title":"AuthTransport.onQuery","url":"\/documentation\/discogsservice\/authtransport\/onquery","kind":"symbol","fragments":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"onQuery"}],"type":"topic","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService/AuthTransport":{"url":"\/documentation\/discogsservice\/authtransport","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"AuthTransport","kind":"identifier"}],"navigatorTitle":[{"text":"AuthTransport","kind":"identifier"}],"abstract":[{"type":"text","text":"A representation of the available transport options to send credentials in authenticated requests."}],"title":"AuthTransport","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/AuthTransport","type":"topic","kind":"symbol","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}

docs/data/documentation/discogsservice/components/headers.json

@@ -1 +1 @@
-{"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/headers"]}],"topicSections":[{"anchor":"Type-Aliases","title":"Type Aliases","generated":true,"identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link"]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components"]]},"schemaVersion":{"minor":3,"major":0,"patch":0},"metadata":{"role":"symbol","title":"Components.Headers","symbolKind":"enum","roleHeading":"Enumeration","fragments":[{"kind":"keyword","text":"enum"},{"kind":"text","text":" "},{"kind":"identifier","text":"Headers"}],"navigatorTitle":[{"text":"Headers","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"externalID":"s:14DiscogsService10ComponentsO7HeadersO"},"abstract":[{"type":"text","text":"Types generated from the "},{"type":"codeVoice","code":"#\/components\/headers"},{"type":"text","text":" section of the OpenAPI document."}],"kind":"symbol","primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"kind":"keyword","text":"enum"},{"kind":"text","text":" "},{"kind":"identifier","text":"Headers"}],"platforms":["macOS"],"languages":["swift"]}]}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components":{"title":"Components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","navigatorTitle":[{"text":"Components","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Components","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/components","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Headers/Link":{"fragments":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"Link"}],"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"Link"}],"url":"\/documentation\/discogsservice\/components\/headers\/link","abstract":[{"text":"Contains URLs for pagination, compliant with RFC 5988.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link","kind":"symbol","type":"topic","title":"Components.Headers.Link"},"doc://DiscogsService/documentation/DiscogsService/Components/Headers":{"fragments":[{"kind":"keyword","text":"enum"},{"kind":"text","text":" "},{"kind":"identifier","text":"Headers"}],"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"Headers"}],"url":"\/documentation\/discogsservice\/components\/headers","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/headers","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers","kind":"symbol","type":"topic","title":"Components.Headers"}}}
+{"primaryContentSections":[{"declarations":[{"tokens":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Headers","kind":"identifier"}],"languages":["swift"],"platforms":["macOS"]}],"kind":"declarations"}],"schemaVersion":{"major":0,"patch":0,"minor":3},"abstract":[{"text":"Types generated from the ","type":"text"},{"type":"codeVoice","code":"#\/components\/headers"},{"text":" section of the OpenAPI document.","type":"text"}],"variants":[{"paths":["\/documentation\/discogsservice\/components\/headers"],"traits":[{"interfaceLanguage":"swift"}]}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers","interfaceLanguage":"swift"},"metadata":{"role":"symbol","roleHeading":"Enumeration","navigatorTitle":[{"text":"Headers","kind":"identifier"}],"externalID":"s:14DiscogsService10ComponentsO7HeadersO","title":"Components.Headers","modules":[{"name":"DiscogsService"}],"fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Headers","kind":"identifier"}],"symbolKind":"enum"},"sections":[],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components"]]},"topicSections":[{"title":"Type Aliases","generated":true,"anchor":"Type-Aliases","identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link"]}],"kind":"symbol","references":{"doc://DiscogsService/documentation/DiscogsService/Components":{"role":"symbol","title":"Components","kind":"symbol","type":"topic","abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"navigatorTitle":[{"kind":"identifier","text":"Components"}],"url":"\/documentation\/discogsservice\/components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","fragments":[{"kind":"keyword","text":"enum"},{"text":" ","kind":"text"},{"kind":"identifier","text":"Components"}]},"doc://DiscogsService/documentation/DiscogsService/Components/Headers":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/headers","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"navigatorTitle":[{"text":"Headers","kind":"identifier"}],"title":"Components.Headers","url":"\/documentation\/discogsservice\/components\/headers","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Headers","kind":"identifier"}],"type":"topic","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Headers/Link":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link","abstract":[{"text":"Contains URLs for pagination, compliant with RFC 5988.","type":"text"}],"navigatorTitle":[{"text":"Link","kind":"identifier"}],"title":"Components.Headers.Link","url":"\/documentation\/discogsservice\/components\/headers\/link","kind":"symbol","fragments":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Link","kind":"identifier"}],"type":"topic","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}

docs/data/documentation/discogsservice/components/headers/link.json

@@ -1 +1 @@
-{"kind":"symbol","abstract":[{"type":"text","text":"Contains URLs for pagination, compliant with RFC 5988."}],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link"},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/headers\/link"]}],"sections":[],"metadata":{"role":"symbol","fragments":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Link","kind":"identifier"}],"navigatorTitle":[{"kind":"identifier","text":"Link"}],"title":"Components.Headers.Link","externalID":"s:14DiscogsService10ComponentsO7HeadersO4Linka","modules":[{"name":"DiscogsService"}],"roleHeading":"Type Alias","symbolKind":"typealias"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers"]]},"schemaVersion":{"patch":0,"major":0,"minor":3},"primaryContentSections":[{"kind":"declarations","declarations":[{"tokens":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"Link"},{"kind":"text","text":" = "},{"preciseIdentifier":"s:SS","kind":"typeIdentifier","text":"String"}],"platforms":["macOS"],"languages":["swift"]}]},{"kind":"content","content":[{"level":2,"anchor":"discussion","type":"heading","text":"Discussion"},{"type":"paragraph","inlineContent":[{"text":"It provides ","type":"text"},{"code":"first","type":"codeVoice"},{"text":", ","type":"text"},{"code":"prev","type":"codeVoice"},{"text":", ","type":"text"},{"code":"next","type":"codeVoice"},{"text":", and ","type":"text"},{"code":"last","type":"codeVoice"},{"text":" links where applicable.","type":"text"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Generated from "},{"code":"#\/components\/headers\/Link","type":"codeVoice"},{"type":"text","text":"."}]}],"type":"aside","style":"note","name":"Remark"}]}],"references":{"doc://DiscogsService/documentation/DiscogsService/Components/Headers/Link":{"fragments":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"Link"}],"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"Link"}],"url":"\/documentation\/discogsservice\/components\/headers\/link","abstract":[{"text":"Contains URLs for pagination, compliant with RFC 5988.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link","kind":"symbol","type":"topic","title":"Components.Headers.Link"},"doc://DiscogsService/documentation/DiscogsService/Components/Headers":{"fragments":[{"kind":"keyword","text":"enum"},{"kind":"text","text":" "},{"kind":"identifier","text":"Headers"}],"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"Headers"}],"url":"\/documentation\/discogsservice\/components\/headers","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/headers","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers","kind":"symbol","type":"topic","title":"Components.Headers"},"doc://DiscogsService/documentation/DiscogsService/Components":{"title":"Components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","navigatorTitle":[{"text":"Components","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Components","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/components","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"}}}
+{"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link","interfaceLanguage":"swift"},"kind":"symbol","hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers"]]},"abstract":[{"type":"text","text":"Contains URLs for pagination, compliant with RFC 5988."}],"primaryContentSections":[{"kind":"declarations","declarations":[{"platforms":["macOS"],"tokens":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Link","kind":"identifier"},{"text":" = ","kind":"text"},{"text":"String","preciseIdentifier":"s:SS","kind":"typeIdentifier"}],"languages":["swift"]}]},{"kind":"content","content":[{"type":"heading","level":2,"text":"Discussion","anchor":"discussion"},{"type":"paragraph","inlineContent":[{"text":"It provides ","type":"text"},{"code":"first","type":"codeVoice"},{"text":", ","type":"text"},{"code":"prev","type":"codeVoice"},{"text":", ","type":"text"},{"code":"next","type":"codeVoice"},{"text":", and ","type":"text"},{"code":"last","type":"codeVoice"},{"text":" links where applicable.","type":"text"}]},{"type":"aside","style":"note","name":"Remark","content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Generated from "},{"type":"codeVoice","code":"#\/components\/headers\/Link"},{"type":"text","text":"."}]}]}]}],"metadata":{"title":"Components.Headers.Link","symbolKind":"typealias","navigatorTitle":[{"text":"Link","kind":"identifier"}],"fragments":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Link","kind":"identifier"}],"modules":[{"name":"DiscogsService"}],"role":"symbol","externalID":"s:14DiscogsService10ComponentsO7HeadersO4Linka","roleHeading":"Type Alias"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/headers\/link"]}],"schemaVersion":{"patch":0,"major":0,"minor":3},"references":{"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components":{"role":"symbol","title":"Components","kind":"symbol","type":"topic","abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"navigatorTitle":[{"kind":"identifier","text":"Components"}],"url":"\/documentation\/discogsservice\/components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","fragments":[{"kind":"keyword","text":"enum"},{"text":" ","kind":"text"},{"kind":"identifier","text":"Components"}]},"doc://DiscogsService/documentation/DiscogsService/Components/Headers":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/headers","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"navigatorTitle":[{"text":"Headers","kind":"identifier"}],"title":"Components.Headers","url":"\/documentation\/discogsservice\/components\/headers","kind":"symbol","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Headers","kind":"identifier"}],"type":"topic","role":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Headers/Link":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Headers\/Link","abstract":[{"text":"Contains URLs for pagination, compliant with RFC 5988.","type":"text"}],"navigatorTitle":[{"text":"Link","kind":"identifier"}],"title":"Components.Headers.Link","url":"\/documentation\/discogsservice\/components\/headers\/link","kind":"symbol","fragments":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Link","kind":"identifier"}],"type":"topic","role":"symbol"}}}

docs/data/documentation/discogsservice/components/parameters/artistid.json

@@ -1 +1 @@
-{"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/parameters\/artistid"]}],"schemaVersion":{"patch":0,"minor":3,"major":0},"sections":[],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters"]]},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistId","interfaceLanguage":"swift"},"abstract":[{"text":"An identifier of an artist.","type":"text"}],"kind":"symbol","metadata":{"role":"symbol","navigatorTitle":[{"kind":"identifier","text":"ArtistId"}],"symbolKind":"typealias","title":"Components.Parameters.ArtistId","fragments":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistId"}],"externalID":"s:14DiscogsService10ComponentsO10ParametersO8ArtistIda","roleHeading":"Type Alias","modules":[{"name":"DiscogsService"}]},"primaryContentSections":[{"kind":"declarations","declarations":[{"languages":["swift"],"tokens":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"text":"ArtistId","kind":"identifier"},{"text":" = ","kind":"text"},{"kind":"typeIdentifier","preciseIdentifier":"s:Si","text":"Int"}],"platforms":["macOS"]}]},{"kind":"content","content":[{"level":2,"anchor":"discussion","type":"heading","text":"Discussion"},{"type":"aside","content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Generated from "},{"type":"codeVoice","code":"#\/components\/parameters\/ArtistId"},{"type":"text","text":"."}]}],"style":"note","name":"Remark"}]}],"references":{"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components":{"title":"Components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","navigatorTitle":[{"text":"Components","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Components","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/components","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"kind":"symbol","role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"title":"Components.Parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the "},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistId":{"title":"Components.Parameters.ArtistId","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistId","navigatorTitle":[{"kind":"identifier","text":"ArtistId"}],"abstract":[{"text":"An identifier of an artist.","type":"text"}],"type":"topic","fragments":[{"text":"typealias","kind":"keyword"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistId"}],"role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters\/artistid","kind":"symbol"}}}
+{"metadata":{"modules":[{"name":"DiscogsService"}],"title":"Components.Parameters.ArtistId","fragments":[{"text":"typealias","kind":"keyword"},{"text":" ","kind":"text"},{"text":"ArtistId","kind":"identifier"}],"navigatorTitle":[{"kind":"identifier","text":"ArtistId"}],"roleHeading":"Type Alias","role":"symbol","externalID":"s:14DiscogsService10ComponentsO10ParametersO8ArtistIda","symbolKind":"typealias"},"schemaVersion":{"major":0,"minor":3,"patch":0},"kind":"symbol","abstract":[{"type":"text","text":"An identifier of an artist."}],"sections":[],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters"]]},"primaryContentSections":[{"declarations":[{"languages":["swift"],"platforms":["macOS"],"tokens":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistId"},{"kind":"text","text":" = "},{"kind":"typeIdentifier","preciseIdentifier":"s:Si","text":"Int"}]}],"kind":"declarations"},{"kind":"content","content":[{"level":2,"type":"heading","anchor":"discussion","text":"Discussion"},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Generated from "},{"type":"codeVoice","code":"#\/components\/parameters\/ArtistId"},{"type":"text","text":"."}]}],"name":"Remark","type":"aside","style":"note"}]}],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistId","interfaceLanguage":"swift"},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/parameters\/artistid"]}],"references":{"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistId":{"url":"\/documentation\/discogsservice\/components\/parameters\/artistid","type":"topic","title":"Components.Parameters.ArtistId","kind":"symbol","fragments":[{"kind":"keyword","text":"typealias"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistId"}],"navigatorTitle":[{"kind":"identifier","text":"ArtistId"}],"abstract":[{"type":"text","text":"An identifier of an artist."}],"role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistId"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"type":"topic","title":"Components.Parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components":{"role":"symbol","title":"Components","kind":"symbol","type":"topic","abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"navigatorTitle":[{"kind":"identifier","text":"Components"}],"url":"\/documentation\/discogsservice\/components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","fragments":[{"kind":"keyword","text":"enum"},{"text":" ","kind":"text"},{"kind":"identifier","text":"Components"}]}}}

docs/data/documentation/discogsservice/components/parameters/artistreleasessort/equatable-implementations.json

@@ -1 +1 @@
-{"kind":"article","schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/Equatable-Implementations"},"metadata":{"role":"collectionGroup","modules":[{"name":"DiscogsService"}],"roleHeading":"API Collection","title":"Equatable Implementations"},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/equatable-implementations"]}],"sections":[],"topicSections":[{"identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/!=(_:_:)"],"title":"Operators","anchor":"Operators","generated":true}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort"]]},"references":{"doc://DiscogsService/documentation/DiscogsService/Components":{"title":"Components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","navigatorTitle":[{"text":"Components","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Components","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/components","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"kind":"symbol","role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"title":"Components.Parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the "},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort/!=(_:_:)":{"kind":"symbol","url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/!=(_:_:)","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/!=(_:_:)","role":"symbol","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"fragments":[{"kind":"keyword","text":"static"},{"kind":"text","text":" "},{"kind":"keyword","text":"func"},{"kind":"text","text":" "},{"kind":"identifier","text":"!="},{"kind":"text","text":" "},{"kind":"text","text":"("},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":", "},{"kind":"typeIdentifier","text":"Self"},{"kind":"text","text":") -> "},{"kind":"typeIdentifier","preciseIdentifier":"s:Sb","text":"Bool"}],"title":"!=(_:_:)"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort","role":"symbol","navigatorTitle":[{"kind":"identifier","text":"ArtistReleasesSort"}],"type":"topic","url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort","abstract":[{"text":"A value to sort the releases of an artist by.","type":"text"}],"fragments":[{"text":"enum","kind":"keyword"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistReleasesSort"}],"title":"Components.Parameters.ArtistReleasesSort","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"}}}
+{"metadata":{"roleHeading":"API Collection","role":"collectionGroup","modules":[{"name":"DiscogsService"}],"title":"Equatable Implementations"},"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/Equatable-Implementations","interfaceLanguage":"swift"},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/equatable-implementations"]}],"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort"]]},"kind":"article","sections":[],"schemaVersion":{"minor":3,"major":0,"patch":0},"topicSections":[{"anchor":"Operators","title":"Operators","generated":true,"identifiers":["doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/!=(_:_:)"]}],"references":{"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"type":"topic","title":"Components.Parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components":{"role":"symbol","title":"Components","kind":"symbol","type":"topic","abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"navigatorTitle":[{"kind":"identifier","text":"Components"}],"url":"\/documentation\/discogsservice\/components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","fragments":[{"kind":"keyword","text":"enum"},{"text":" ","kind":"text"},{"kind":"identifier","text":"Components"}]},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort":{"title":"Components.Parameters.ArtistReleasesSort","navigatorTitle":[{"text":"ArtistReleasesSort","kind":"identifier"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort","kind":"symbol","abstract":[{"text":"A value to sort the releases of an artist by.","type":"text"}],"role":"symbol","type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"ArtistReleasesSort","kind":"identifier"}],"url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort/!=(_:_:)":{"title":"!=(_:_:)","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/!=(_:_:)","kind":"symbol","abstract":[{"type":"text","text":"Returns a Boolean value indicating whether two values are not equal."}],"role":"symbol","type":"topic","fragments":[{"text":"static","kind":"keyword"},{"text":" ","kind":"text"},{"text":"func","kind":"keyword"},{"text":" ","kind":"text"},{"text":"!=","kind":"identifier"},{"text":" ","kind":"text"},{"text":"(","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":", ","kind":"text"},{"text":"Self","kind":"typeIdentifier"},{"text":") -> ","kind":"text"},{"text":"Bool","kind":"typeIdentifier","preciseIdentifier":"s:Sb"}],"url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/!=(_:_:)"}}}

docs/data/documentation/discogsservice/components/parameters/artistreleasessort/format.json

@@ -1 +1 @@
-{"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort"]]},"variants":[{"traits":[{"interfaceLanguage":"swift"}],"paths":["\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/format"]}],"primaryContentSections":[{"declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"format","kind":"identifier"}],"platforms":["macOS"],"languages":["swift"]}],"kind":"declarations"}],"metadata":{"roleHeading":"Case","role":"symbol","externalID":"s:14DiscogsService10ComponentsO10ParametersO18ArtistReleasesSortO6formatyA2GmF","fragments":[{"kind":"keyword","text":"case"},{"kind":"text","text":" "},{"kind":"identifier","text":"format"}],"title":"Components.Parameters.ArtistReleasesSort.format","modules":[{"name":"DiscogsService"}],"symbolKind":"case"},"kind":"symbol","schemaVersion":{"minor":3,"patch":0,"major":0},"sections":[],"identifier":{"interfaceLanguage":"swift","url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/format"},"references":{"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort/format":{"abstract":[],"fragments":[{"kind":"keyword","text":"case"},{"text":" ","kind":"text"},{"text":"format","kind":"identifier"}],"url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/format","title":"Components.Parameters.ArtistReleasesSort.format","role":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/format","kind":"symbol","type":"topic"},"doc://DiscogsService/documentation/DiscogsService/Components":{"title":"Components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","navigatorTitle":[{"text":"Components","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Components","kind":"identifier"}],"role":"symbol","url":"\/documentation\/discogsservice\/components","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"role":"collection","title":"DiscogsService","kind":"symbol","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","abstract":[],"type":"topic","url":"\/documentation\/discogsservice"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"kind":"symbol","role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"title":"Components.Parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"abstract":[{"type":"text","text":"Types generated from the "},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort":{"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort","role":"symbol","navigatorTitle":[{"kind":"identifier","text":"ArtistReleasesSort"}],"type":"topic","url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort","abstract":[{"text":"A value to sort the releases of an artist by.","type":"text"}],"fragments":[{"text":"enum","kind":"keyword"},{"kind":"text","text":" "},{"kind":"identifier","text":"ArtistReleasesSort"}],"title":"Components.Parameters.ArtistReleasesSort","kind":"symbol"}}}
+{"variants":[{"paths":["\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/format"],"traits":[{"interfaceLanguage":"swift"}]}],"schemaVersion":{"patch":0,"major":0,"minor":3},"kind":"symbol","sections":[],"identifier":{"url":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/format","interfaceLanguage":"swift"},"hierarchy":{"paths":[["doc:\/\/DiscogsService\/documentation\/DiscogsService","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort"]]},"primaryContentSections":[{"declarations":[{"tokens":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"format","kind":"identifier"}],"languages":["swift"],"platforms":["macOS"]}],"kind":"declarations"}],"metadata":{"roleHeading":"Case","title":"Components.Parameters.ArtistReleasesSort.format","modules":[{"name":"DiscogsService"}],"role":"symbol","fragments":[{"text":"case","kind":"keyword"},{"text":" ","kind":"text"},{"text":"format","kind":"identifier"}],"externalID":"s:14DiscogsService10ComponentsO10ParametersO18ArtistReleasesSortO6formatyA2GmF","symbolKind":"case"},"references":{"doc://DiscogsService/documentation/DiscogsService/Components":{"role":"symbol","title":"Components","kind":"symbol","type":"topic","abstract":[{"type":"text","text":"Types generated from the components section of the OpenAPI document."}],"navigatorTitle":[{"kind":"identifier","text":"Components"}],"url":"\/documentation\/discogsservice\/components","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components","fragments":[{"kind":"keyword","text":"enum"},{"text":" ","kind":"text"},{"kind":"identifier","text":"Components"}]},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort/format":{"role":"symbol","fragments":[{"text":"case","kind":"keyword"},{"kind":"text","text":" "},{"text":"format","kind":"identifier"}],"title":"Components.Parameters.ArtistReleasesSort.format","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort\/format","abstract":[],"type":"topic","url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort\/format","kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters/ArtistReleasesSort":{"title":"Components.Parameters.ArtistReleasesSort","navigatorTitle":[{"text":"ArtistReleasesSort","kind":"identifier"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters\/ArtistReleasesSort","kind":"symbol","abstract":[{"text":"A value to sort the releases of an artist by.","type":"text"}],"role":"symbol","type":"topic","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"ArtistReleasesSort","kind":"identifier"}],"url":"\/documentation\/discogsservice\/components\/parameters\/artistreleasessort"},"doc://DiscogsService/documentation/DiscogsService/Components/Parameters":{"type":"topic","title":"Components.Parameters","navigatorTitle":[{"text":"Parameters","kind":"identifier"}],"identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService\/Components\/Parameters","abstract":[{"text":"Types generated from the ","type":"text"},{"code":"#\/components\/parameters","type":"codeVoice"},{"text":" section of the OpenAPI document.","type":"text"}],"role":"symbol","url":"\/documentation\/discogsservice\/components\/parameters","fragments":[{"text":"enum","kind":"keyword"},{"text":" ","kind":"text"},{"text":"Parameters","kind":"identifier"}],"kind":"symbol"},"doc://DiscogsService/documentation/DiscogsService":{"title":"DiscogsService","role":"collection","abstract":[],"kind":"symbol","type":"topic","identifier":"doc:\/\/DiscogsService\/documentation\/DiscogsService","url":"\/documentation\/discogsservice"}}}