diff --git a/Package.resolved b/Package.resolved index 9562ce0b..f334cf8b 100644 --- a/Package.resolved +++ b/Package.resolved @@ -21,7 +21,7 @@ { "identity" : "swift-docc-symbolkit", "kind" : "remoteSourceControl", - "location" : "https://github.com/apple/swift-docc-symbolkit.git", + "location" : "https://github.com/swiftlang/swift-docc-symbolkit.git", "state" : { "revision" : "b45d1f2ed151d057b54504d653e0da5552844e34", "version" : "1.0.0" diff --git a/Package.swift b/Package.swift index 1ec38a7c..6fb9c280 100644 --- a/Package.swift +++ b/Package.swift @@ -24,7 +24,7 @@ let package = Package( dependencies: [ .package(url: "https://github.com/jpsim/Yams.git", from: "5.0.6"), .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.2.0"), - .package(url: "https://github.com/apple/swift-docc-symbolkit.git", from: "1.0.0"), + .package(url: "https://github.com/swiftlang/swift-docc-symbolkit.git", from: "1.0.0"), .package(url: "https://github.com/mattpolzin/OpenAPIKit.git", from: "3.0.0"), ], targets: [ @@ -52,8 +52,8 @@ let package = Package( .target( name: "Integration", dependencies: [ - "OpenAPI", - "DocC", + "OpenAPI", + "DocC", "Core", .product(name: "SymbolKit", package: "swift-docc-symbolkit") ], @@ -63,8 +63,8 @@ let package = Package( .target( name: "OpenAPItoSymbolGraph", dependencies: [ - "OpenAPI", - "DocC", + "OpenAPI", + "DocC", "Integration", "Core", .product(name: "SymbolKit", package: "swift-docc-symbolkit") @@ -98,9 +98,9 @@ let package = Package( .testTarget( name: "OpenAPItoSymbolGraphTests", dependencies: [ - "OpenAPI", - "DocC", - "Integration", + "OpenAPI", + "DocC", + "Integration", "OpenAPItoSymbolGraph", "Core", "CLI", diff --git a/RegistryAPI.docc/Extensions/PackageMetadata.md b/RegistryAPI.docc/Extensions/PackageMetadata.md new file mode 100644 index 00000000..0a941c7a --- /dev/null +++ b/RegistryAPI.docc/Extensions/PackageMetadata.md @@ -0,0 +1,157 @@ +# ``RegistryAPI/PackageMetadata`` + +A comprehensive representation of metadata for a Swift package. + +## Overview + +The `PackageMetadata` structure contains all descriptive information about a Swift package, including details about the package's author, license, and available versions. + +```swift +// Example: Fetching and using package metadata +let url = URL(string: "https://registry.example.com/mona/LinkedList")! +let (data, _) = try await URLSession.shared.data(from: url) +let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) + +// Use metadata properties +print("Package name: \(metadata.name)") +print("Latest version: \(metadata.latestVersion)") +print("Available versions: \(metadata.versions.joined(separator: ", "))") +``` + +Package metadata provides a complete picture of a package, including: + +- Basic information like name, version, and description +- Author and organization information +- License details +- Repository location +- Available versions + +## Topics + +### Essential Properties + +- ``name`` +- ``description`` +- ``version`` +- ``latestVersion`` + +### Author Information + +- ``author`` +- ``PackageAuthor`` +- ``organization`` +- ``PackageOrganization`` + +### Package Versions + +- ``versions`` +- ``listedVersions`` +- ``ListedRelease`` + +### Package Resources + +- ``repository`` +- ``license`` +- ``readmeURL`` +- ``keywords`` + +## Structure + +```json +{ + "name": "LinkedList", + "description": "A linked list implementation for Swift", + "keywords": ["data-structure", "list", "collection"], + "version": "1.1.1", + "author": { + "name": "J. Appleseed", + "email": "japplseed@example.com", + "url": "https://example.com/japplseed" + }, + "organization": { + "name": "Example Organization", + "url": "https://example.com", + "description": "Organization that maintains the package" + }, + "license": { + "name": "MIT", + "url": "https://opensource.org/licenses/MIT" + }, + "repository": { + "type": "git", + "url": "https://github.com/mona/LinkedList.git" + }, + "readmeURL": "https://registry.example.com/mona/LinkedList/1.1.1/README.md", + "latestVersion": "1.1.1", + "versions": ["1.0.0", "1.0.1", "1.1.0", "1.1.1"] +} +``` + +## Accessing Metadata + +You can retrieve package metadata using the package identifier endpoint: + +```swift +func fetchPackageMetadata(scope: String, name: String) async throws -> PackageMetadata { + let url = URL(string: "https://registry.example.com/\(scope)/\(name)")! + + var request = URLRequest(url: url) + request.addValue("application/json", forHTTPHeaderField: "Accept") + + let (data, response) = try await URLSession.shared.data(for: request) + + guard let httpResponse = response as? HTTPURLResponse, + (200..<300).contains(httpResponse.statusCode) else { + throw FetchError.invalidResponse + } + + return try JSONDecoder().decode(PackageMetadata.self, from: data) +} +``` + +## Required and Optional Fields + +The following fields are required in every package metadata response: + +- `name`: Package name +- `version`: Current version +- `description`: Brief description of the package +- `license`: License information + +All other fields are optional and may not be present in all responses. + +## Handling Missing Fields + +When working with package metadata, it's important to handle optional fields gracefully: + +```swift +// Example: Handling optional fields +func displayPackageInfo(_ metadata: PackageMetadata) { + // Required fields + print("Package: \(metadata.name)") + print("Description: \(metadata.description)") + + // Optional fields + if let author = metadata.author { + print("Author: \(author.name)") + if let email = author.email { + print("Contact: \(email)") + } + } + + if let org = metadata.organization { + print("Organization: \(org.name)") + } + + // Keywords + if let keywords = metadata.keywords, !keywords.isEmpty { + print("Keywords: \(keywords.joined(separator: ", "))") + } +} +``` + +## See Also + +- ``RegistryAPI/__scope___name_`` +- ``RegistryAPI/ReleaseResource`` +- ``RegistryAPI/ListedRelease`` diff --git a/RegistryAPI.docc/RegistryAPI.md b/RegistryAPI.docc/RegistryAPI.md index 50920bf2..0e5a44ab 100644 --- a/RegistryAPI.docc/RegistryAPI.md +++ b/RegistryAPI.docc/RegistryAPI.md @@ -1,7 +1,66 @@ -# RegistryAPI +# ``RegistryAPI`` -Swift Package Registry API documentation. +@Metadata { + @DisplayName("Registry API") + @TitleHeading("Swift Package Registry API") + @DocumentationExtension(mergeBehavior: append) +} + +Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages. ## Overview -This documentation provides details about the Swift Package Registry API endpoints and schemas, generated from the OpenAPI specification. +The Swift Package Registry API provides a robust interface for package management that follows open standards. Using this API, you can: + +- **Discover** packages through search and metadata +- **Retrieve** package releases including source code and manifests +- **Publish** your own packages for others to use +- **Authenticate** to access private packages or perform privileged operations + +![A diagram showing the workflow of package discovery, retrieval and publishing](registry_workflow.png) + +The API follows RESTful principles with well-defined endpoints for each resource type. All requests and responses use standard HTTP methods and status codes, with JSON-formatted data. + +```swift +// Example: Retrieve package metadata +let url = URL(string: "https://registry.example.com/mona/LinkedList")! +let (data, response) = try await URLSession.shared.data(from: url) +let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) + +print("Package: \(metadata.name)") +print("Latest version: \(metadata.latestVersion)") +print("Available versions: \(metadata.versions.joined(separator: ", "))") +``` + +## Topics + +### API Endpoints + +- +- ``_identifiers`` +- ``_login`` +- ``__scope___name_`` +- ``__scope___name___version_`` +- ``__scope___name___version_.zip`` +- ``__scope___name___version__package.swift`` + +### Data Models + +- ``PackageMetadata`` +- ``ReleaseResource`` +- ``ProblemDetails`` +- ``Identifier`` +- ``Identifiers`` +- ``Releases`` +- ``ReleaseMetadata`` +- ``ReleaseSignature`` +- ``PublishResponse`` + +### Guides + +- +- +- +- +- +- diff --git a/RegistryAPI.docc/Resources/VersionEndpoint.md b/RegistryAPI.docc/Resources/VersionEndpoint.md new file mode 100644 index 00000000..5b7f81a1 --- /dev/null +++ b/RegistryAPI.docc/Resources/VersionEndpoint.md @@ -0,0 +1,81 @@ +# ``RegistryAPI/__scope___name___version_`` + +Interact with a specific version of a Swift package. + +## Overview + +This endpoint provides access to a specific version of a package in the registry. It supports both retrieving metadata about a version and publishing new versions. + +## Getting Version Information + +Retrieve information about a specific version of a package: + +```http +GET /{scope}/{name}/{version} +``` + +### Response + +On success, returns a `200 OK` response with a `ReleaseResource` object in the response body: + +```json +{ + "id": "mona/LinkedList/1.1.1", + "version": "1.1.1", + "resources": [ + { + "name": "source-archive", + "type": "application/zip", + "checksum": "a2ac54cf25fbc1ad0028f03f0aa4b96833b83bb05a14e510892bb27dea4dc812", + "signing": { + "signatureBase64Encoded": "ZXhhbXBsZSBzaWduYXR1cmU=", + "signatureFormat": "cms-1.0.0" + } + } + ], + "metadata": { + "author": { + "name": "J. Appleseed" + }, + "description": "A linked list implementation for Swift", + "licenseURL": "https://opensource.org/licenses/MIT" + } +} +``` + +## Publishing a New Version + +To publish a new version of a package: + +```http +PUT /{scope}/{name}/{version} +Content-Type: application/octet-stream +X-Swift-Package-Signature: sha256=[Base64 encoded signature] +``` + +The request body should contain the package archive in ZIP format. + +### Response Codes + +When publishing a package version, the registry may respond with: + +| Status Code | Description | +|-------------|-------------| +| 201 Created | Version published successfully | +| 202 Accepted | Version accepted for processing | +| 400 Bad Request | Invalid request format | +| 401 Unauthorized | Authentication required | +| 403 Forbidden | Insufficient permissions | +| 409 Conflict | Version already exists | +| 413 Payload Too Large | Package size exceeds limits | +| 422 Unprocessable Entity | Package validation failed | + +## Availability + +The endpoint is available for both public and private packages. Private packages require authentication. + +## See Also + +- ``RegistryAPI/__scope___name_`` +- ``RegistryAPI/__scope___name___version_.zip`` +- ``RegistryAPI/ReleaseResource`` diff --git a/RegistryAPI.docc/Resources/css/custom.css b/RegistryAPI.docc/Resources/css/custom.css new file mode 100644 index 00000000..51ad5783 --- /dev/null +++ b/RegistryAPI.docc/Resources/css/custom.css @@ -0,0 +1,128 @@ +/* Custom styling for Registry API documentation */ + +/* Enhance HTTP method labels */ +.method-label { + display: inline-block; + padding: 3px 8px; + border-radius: 4px; + font-weight: bold; + font-family: monospace; + margin-right: 8px; +} + +.method-get { + background-color: #61affe; + color: white; +} + +.method-post { + background-color: #49cc90; + color: white; +} + +.method-put { + background-color: #fca130; + color: white; +} + +.method-delete { + background-color: #f93e3e; + color: white; +} + +/* Enhance code blocks */ +pre code { + border-left: 4px solid #0070c9; +} + +/* Enhance tables */ +table { + border-collapse: collapse; + width: 100%; + margin: 1em 0; +} + +table th { + background-color: #f5f5f7; + font-weight: bold; +} + +table th, table td { + padding: 8px 12px; + border: 1px solid #e1e1e1; +} + +/* HTTP status codes */ +.status-success { + color: #2e7d32; +} + +.status-redirect { + color: #0277bd; +} + +.status-client-error { + color: #c62828; +} + +.status-server-error { + color: #8e24aa; +} + +/* Add endpoint path styling */ +.endpoint-path { + font-family: monospace; + background-color: #f5f5f7; + padding: 2px 6px; + border-radius: 4px; + word-break: break-all; +} + +/* Custom information box */ +.info-box { + background-color: #e8f4f8; + border-left: 4px solid #0070c9; + padding: 12px 16px; + margin: 1em 0; + border-radius: 4px; +} + +.warning-box { + background-color: #fff3e0; + border-left: 4px solid #ff9800; + padding: 12px 16px; + margin: 1em 0; + border-radius: 4px; +} + +/* Improved navigation */ +nav { + padding: 8px 0; +} + +nav a { + text-decoration: none; + transition: color 0.2s; +} + +nav a:hover { + color: #0070c9; +} + +/* Improved typography for readability */ +p, li { + line-height: 1.6; +} + +h2, h3, h4 { + margin-top: 1.5em; + margin-bottom: 0.5em; +} + +/* Fix for code snippets on mobile */ +@media (max-width: 768px) { + pre { + max-width: 100%; + overflow-x: auto; + } +} diff --git a/RegistryAPI.docc/Resources/images/performance_diagram.svg b/RegistryAPI.docc/Resources/images/performance_diagram.svg new file mode 100644 index 00000000..2a45de32 --- /dev/null +++ b/RegistryAPI.docc/Resources/images/performance_diagram.svg @@ -0,0 +1,98 @@ + + + + + + + Performance Optimization Techniques + + + + Client Application + + + + Memory Cache + Fast in-memory storage + + + + Disk Cache + Persistent storage + + + + Request Manager + Deduplication & Batching + + + + Prefetching + Anticipate future needs + + + + Registry Server + + + + API Endpoints + Package resources + + + + Rate Limiting + Throttles requests + + + + Conditional Responses + ETags & 304 Not Modified + + + + Compression + Reduces payload size + + + + Network Optimizations + + + â€ĸ Connection Pooling + â€ĸ Parallel Requests + â€ĸ Prioritization + â€ĸ Retry with Backoff + + + + + Cache Hit + + + + + + + + + + + If-None-Match: "etag" + + + + + 304 Not Modified + + + + + Compressed Response + + + + + Client respects limits + + diff --git a/RegistryAPI.docc/Resources/images/registry_workflow.svg b/RegistryAPI.docc/Resources/images/registry_workflow.svg new file mode 100644 index 00000000..41a59145 --- /dev/null +++ b/RegistryAPI.docc/Resources/images/registry_workflow.svg @@ -0,0 +1,69 @@ + + + + + + + Swift Package Registry Workflow + + + + Discover + + + + 🔍 + Search + + + 📋 + Browse + + + ℹī¸ + Get Info + + + + Retrieve + + + + đŸ“Ļ + Download + + + 📄 + Manifest + + + đŸ”ĸ + Versions + + + + Publish + + + + 🔐 + Authenticate + + + âŦ†ī¸ + Upload + + + 🔄 + Update + + + + + + + + + + Registry API enables seamless package discovery, retrieval, and publishing + diff --git a/RegistryAPI.docc/Resources/registry-custom.js b/RegistryAPI.docc/Resources/registry-custom.js new file mode 100644 index 00000000..5c309f05 --- /dev/null +++ b/RegistryAPI.docc/Resources/registry-custom.js @@ -0,0 +1,55 @@ +// Custom JavaScript for Registry API Documentation + +document.addEventListener('DOMContentLoaded', function() { + // Add custom CSS + const linkElement = document.createElement('link'); + linkElement.rel = 'stylesheet'; + linkElement.href = '../Resources/css/custom.css'; + document.head.appendChild(linkElement); + + // Enhance HTTP method displays + document.querySelectorAll('code').forEach(function(element) { + const text = element.textContent.trim(); + if (['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(text)) { + element.classList.add('method-label'); + element.classList.add(`method-${text.toLowerCase()}`); + } + }); + + // Add styling to HTTP status codes + document.querySelectorAll('td').forEach(function(element) { + const text = element.textContent.trim(); + if (text.match(/^[1-5][0-9][0-9]\s/)) { + const statusCode = parseInt(text); + if (statusCode >= 200 && statusCode < 300) { + element.classList.add('status-success'); + } else if (statusCode >= 300 && statusCode < 400) { + element.classList.add('status-redirect'); + } else if (statusCode >= 400 && statusCode < 500) { + element.classList.add('status-client-error'); + } else if (statusCode >= 500) { + element.classList.add('status-server-error'); + } + } + }); + + // Enhance endpoint paths + document.querySelectorAll('p').forEach(function(element) { + if (element.textContent.includes('/{scope}/{name}')) { + element.innerHTML = element.innerHTML.replace( + /\/({\w+})\/({[\w-]+})/g, + '/$1/$2' + ); + } + }); + + // Add information boxes + document.querySelectorAll('p').forEach(function(element) { + if (element.textContent.startsWith('Note:')) { + element.classList.add('info-box'); + } + if (element.textContent.startsWith('Warning:')) { + element.classList.add('warning-box'); + } + }); +}); diff --git a/RegistryAPI.docc/Tutorials/Authentication.md b/RegistryAPI.docc/Tutorials/Authentication.md new file mode 100644 index 00000000..dfefb18d --- /dev/null +++ b/RegistryAPI.docc/Tutorials/Authentication.md @@ -0,0 +1,70 @@ +# Authentication + +Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing. + +## Overview + +The Swift Package Registry API uses token-based authentication to secure access to private packages and privileged operations like publishing. This guide explains how to authenticate your requests. + +## Obtaining an Authentication Token + +To get an authentication token, you'll typically use the login endpoint: + +```swift +// Create login request +let loginURL = URL(string: "https://registry.example.com/login")! +var request = URLRequest(url: loginURL) +request.httpMethod = "POST" +request.setValue("application/json", forHTTPHeaderField: "Content-Type") + +// Set credentials - implementation depends on registry provider +let credentials = ["username": "your-username", "password": "your-password"] +request.httpBody = try JSONEncoder().encode(credentials) + +// Send request +let (data, response) = try await URLSession.shared.data(for: request) + +// Parse token from response +let tokenResponse = try JSONDecoder().decode(TokenResponse.self, from: data) +let authToken = tokenResponse.token +``` + +## Using Authentication Tokens + +Once you have a token, include it in your request headers: + +```swift +// Create authenticated request +let packageURL = URL(string: "https://registry.example.com/mona/LinkedList/1.1.1")! +var request = URLRequest(url: packageURL) + +// Add the authorization header +request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization") + +// Send request +let (data, response) = try await URLSession.shared.data(for: request) +``` + +## Token Management + +Authentication tokens typically have an expiration period. You should: + +1. Store tokens securely (e.g., in the keychain on Apple platforms) +2. Handle token refresh when tokens expire +3. Never expose tokens in client-side code for public applications + +## Authentication for Different Operations + +Different operations may require different scopes or permissions: + +| Operation | Required Permissions | +|-----------|---------------------| +| Read public packages | None (anonymous access) | +| Read private packages | `read` scope | +| Publish packages | `write` scope | +| Manage organization | `admin` scope | + +## Next Steps + +- Learn how to packages to the registry +- Review specific endpoint documentation for authorization requirements diff --git a/RegistryAPI.docc/Tutorials/ErrorCodes.md b/RegistryAPI.docc/Tutorials/ErrorCodes.md new file mode 100644 index 00000000..2b26490f --- /dev/null +++ b/RegistryAPI.docc/Tutorials/ErrorCodes.md @@ -0,0 +1,165 @@ +# Error Codes + +Understand how the Swift Package Registry API communicates errors and how to handle them. + +## Overview + +The Swift Package Registry API uses standard HTTP status codes combined with detailed error responses to provide clear information about what went wrong. All error responses follow the RFC 7807 Problem Details format, allowing both machines and humans to understand the nature of errors. + +## Problem Details Response Format + +When an error occurs, the API returns a problem details object with the following structure: + +```json +{ + "type": "https://registry.example.com/docs/errors/invalid-version", + "title": "Invalid Version Format", + "status": 400, + "detail": "The version '1.x' does not conform to semantic versioning requirements", + "instance": "urn:uuid:6493675d-9af4-4f9d-b8c3-90c5e33f3db1" +} +``` + +The object contains these fields: + +- `type`: A URI reference that identifies the problem type +- `title`: A short, human-readable summary of the problem +- `status`: The HTTP status code +- `detail`: A human-readable explanation specific to this occurrence of the problem +- `instance`: A URI reference that identifies the specific occurrence of the problem + +## Common Error Types + +### Authentication Errors (401, 403) + +| Status | Type | Description | +|--------|------|-------------| +| 401 | unauthorized | The request lacks valid authentication credentials | +| 403 | forbidden | The authenticated user lacks permission for the requested operation | + +```swift +// Example: Handling an authentication error +do { + let (data, response) = try await session.data(for: request) + guard let httpResponse = response as? HTTPURLResponse else { return } + + if httpResponse.statusCode == 401 { + // Handle unauthorized error - request new credentials + refreshCredentials() + } else if httpResponse.statusCode == 403 { + // Handle forbidden error - inform user they lack permission + showPermissionError() + } +} catch { + // Handle network errors +} +``` + +### Resource Errors (404, 410) + +| Status | Type | Description | +|--------|------|-------------| +| 404 | not-found | The requested resource does not exist | +| 410 | gone | The resource previously existed but is no longer available | + +### Request Validation Errors (400, 422) + +| Status | Type | Description | +|--------|------|-------------| +| 400 | bad-request | The request could not be understood or was missing required parameters | +| 422 | validation-failed | The request was well-formed but contained semantic errors | + +### Rate Limiting Errors (429) + +| Status | Type | Description | +|--------|------|-------------| +| 429 | too-many-requests | The client has sent too many requests in a given time period | + +Rate limiting responses include additional headers: + +- `RateLimit-Limit`: The maximum number of requests allowed in the current time window +- `RateLimit-Remaining`: The number of requests remaining in the current time window +- `RateLimit-Reset`: The time when the current rate limit window resets (in UTC epoch seconds) + +### Server Errors (500, 503) + +| Status | Type | Description | +|--------|------|-------------| +| 500 | server-error | An unexpected error occurred on the server | +| 503 | service-unavailable | The service is temporarily unavailable | + +## Best Practices for Error Handling + +1. **Always check status codes**: Validate HTTP status codes before processing responses +2. **Parse problem details**: Extract the detailed error information from the response body +3. **Implement exponential backoff**: For rate limiting and server errors, use increasing delays between retries +4. **Present meaningful messages**: Translate error responses into user-friendly messages +5. **Log rich error data**: Include the error `type` and `instance` in logs for easier troubleshooting + +```swift +// Example: Comprehensive error handling with retry logic +func fetchPackage(scope: String, name: String, version: String) async throws -> Data { + var retryCount = 0 + let maxRetries = 3 + + while true { + do { + let url = URL(string: "https://registry.example.com/\(scope)/\(name)/\(version).zip")! + let (data, response) = try await URLSession.shared.data(from: url) + + guard let httpResponse = response as? HTTPURLResponse else { + throw RegistryError.invalidResponse + } + + switch httpResponse.statusCode { + case 200..<300: + return data + case 429: + if retryCount >= maxRetries { + throw RegistryError.rateLimitExceeded + } + + // Parse retry-after header or use exponential backoff + let retryAfter = httpResponse.value(forHTTPHeaderField: "Retry-After") + .flatMap(Int.init) ?? Int(pow(2.0, Double(retryCount + 1))) + + // Wait before retrying + try await Task.sleep(nanoseconds: UInt64(retryAfter * 1_000_000_000)) + retryCount += 1 + continue + + case 400..<500: + // Parse problem details + let problem = try JSONDecoder().decode(ProblemDetails.self, from: data) + throw RegistryError.clientError(problem) + + case 500..<600: + if retryCount >= maxRetries { + throw RegistryError.serverError + } + + // Use exponential backoff for server errors + try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(retryCount + 1)) * 1_000_000_000)) + retryCount += 1 + continue + + default: + throw RegistryError.unknownError + } + } catch { + if retryCount >= maxRetries { + throw error + } + + // Network error - retry with backoff + try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(retryCount + 1)) * 1_000_000_000)) + retryCount += 1 + } + } +} +``` + +## See Also + +- +- ``RegistryAPI/ProblemDetails`` diff --git a/RegistryAPI.docc/Tutorials/GettingStarted.md b/RegistryAPI.docc/Tutorials/GettingStarted.md new file mode 100644 index 00000000..0f089489 --- /dev/null +++ b/RegistryAPI.docc/Tutorials/GettingStarted.md @@ -0,0 +1,54 @@ +# Getting Started with Swift Package Registry + +Learn how to use the Swift Package Registry API to discover and retrieve packages. + +## Overview + +The Swift Package Registry API provides a standardized way to interact with package repositories. This guide will help you understand the basic operations and how to make your first API calls. + +## Discovering Packages + +To find a package in the registry, you can use the package identifier lookup endpoint: + +```swift +// Find all packages matching a partial name +let url = URL(string: "https://registry.example.com/identifiers?query=networking")! +let (data, _) = try await URLSession.shared.data(from: url) +// Parse the JSON response +let identifiers = try JSONDecoder().decode([Identifier].self, from: data) +``` + +## Retrieving Package Information + +Once you have a package identifier, you can retrieve detailed information: + +```swift +// Get information about a specific package +let packageScope = "mona" +let packageName = "LinkedList" +let url = URL(string: "https://registry.example.com/\(packageScope)/\(packageName)")! +let (data, _) = try await URLSession.shared.data(from: url) +// Parse the JSON response +let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) +``` + +## Downloading a Package Version + +To download a specific version of a package: + +```swift +// Download a specific version +let packageScope = "mona" +let packageName = "LinkedList" +let version = "1.1.1" +let url = URL(string: "https://registry.example.com/\(packageScope)/\(packageName)/\(version).zip")! +let (zipData, _) = try await URLSession.shared.data(from: url) +// Save or process the zip file +try zipData.write(to: zipFileURL) +``` + +## Next Steps + +- Learn about to access private packages +- Explore how to your own packages to the registry +- Review the full API reference for detailed endpoint information diff --git a/RegistryAPI.docc/Tutorials/Performance.md b/RegistryAPI.docc/Tutorials/Performance.md new file mode 100644 index 00000000..0117bb6a --- /dev/null +++ b/RegistryAPI.docc/Tutorials/Performance.md @@ -0,0 +1,479 @@ +# Performance Optimization + +Learn how to optimize your Swift Package Registry API usage for maximum performance. + +## Overview + +Optimizing your interactions with the Swift Package Registry API can significantly improve your application's performance and user experience. This guide covers best practices for efficient API usage, including caching strategies, concurrent requests, and optimizing data transfers. + +![Diagram showing performance optimization techniques](performance_diagram.png) + +## Caching Strategies + +Implementing effective caching is one of the most important ways to improve performance when working with the Registry API. + +### Memory Caching + +For frequently accessed data that doesn't change often, implement in-memory caching: + +```swift +class RegistryAPIClient { + // Simple memory cache with expiration support + private class Cache { + private struct CacheEntry { + let value: V + let expirationDate: Date + } + + private var storage = [K: CacheEntry]() + private let lock = NSLock() + + func set(_ value: V, forKey key: K, expirationInterval: TimeInterval) { + lock.lock() + defer { lock.unlock() } + + let expirationDate = Date().addingTimeInterval(expirationInterval) + storage[key] = CacheEntry(value: value, expirationDate: expirationDate) + } + + func get(forKey key: K) -> V? { + lock.lock() + defer { lock.unlock() } + + guard let entry = storage[key], entry.expirationDate > Date() else { + // Remove expired entry if it exists + storage.removeValue(forKey: key) + return nil + } + + return entry.value + } + + func removeAll() { + lock.lock() + defer { lock.unlock() } + storage.removeAll() + } + } + + // Cache for package metadata (larger TTL since metadata changes less frequently) + private let metadataCache = Cache() + + // Cache for package identifiers (shorter TTL since search results may change) + private let identifierCache = Cache() + + func fetchPackageMetadata(scope: String, name: String) async throws -> PackageMetadata { + let cacheKey = "\(scope)/\(name)" + + // Check cache first + if let cachedMetadata = metadataCache.get(forKey: cacheKey) { + return cachedMetadata + } + + // Fetch from network + let url = URL(string: "https://registry.example.com/\(scope)/\(name)")! + let (data, _) = try await URLSession.shared.data(from: url) + let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) + + // Cache result (30 minute TTL) + metadataCache.set(metadata, forKey: cacheKey, expirationInterval: 30 * 60) + + return metadata + } +} +``` + +### Persistent Caching + +For data that should persist between app launches: + +```swift +class PersistentCache { + private let fileManager = FileManager.default + private let cacheDirectory: URL + + init() throws { + let cacheURL = try fileManager.url( + for: .cachesDirectory, + in: .userDomainMask, + appropriateFor: nil, + create: true + ) + cacheDirectory = cacheURL.appendingPathComponent("RegistryCache", isDirectory: true) + + if !fileManager.fileExists(atPath: cacheDirectory.path) { + try fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true) + } + } + + func cacheData(_ data: Data, forKey key: String, expirationInterval: TimeInterval) throws { + let fileURL = cacheDirectory.appendingPathComponent(key.md5Hash) + try data.write(to: fileURL) + + // Store metadata including expiration + let metadata: [String: Any] = [ + "key": key, + "expiration": Date().addingTimeInterval(expirationInterval).timeIntervalSince1970 + ] + let metadataURL = fileURL.appendingPathExtension("metadata") + let metadataData = try JSONSerialization.data(withJSONObject: metadata) + try metadataData.write(to: metadataURL) + } + + func getData(forKey key: String) throws -> Data? { + let fileURL = cacheDirectory.appendingPathComponent(key.md5Hash) + let metadataURL = fileURL.appendingPathExtension("metadata") + + // Check if file exists + guard fileManager.fileExists(atPath: fileURL.path), + fileManager.fileExists(atPath: metadataURL.path) else { + return nil + } + + // Check expiration + let metadataData = try Data(contentsOf: metadataURL) + let metadata = try JSONSerialization.jsonObject(with: metadataData) as? [String: Any] + + if let expirationTimestamp = metadata?["expiration"] as? TimeInterval, + Date(timeIntervalSince1970: expirationTimestamp) > Date() { + // Not expired, return data + return try Data(contentsOf: fileURL) + } else { + // Expired, clean up files + try? fileManager.removeItem(at: fileURL) + try? fileManager.removeItem(at: metadataURL) + return nil + } + } +} +``` + +### Conditional Requests + +Use HTTP conditional requests with ETag or Last-Modified headers to avoid downloading unchanged data: + +```swift +class ConditionalRequestClient { + private var etagStorage: [String: String] = [:] + + func fetchWithConditionalRequest(url: URL) async throws -> Data { + var request = URLRequest(url: url) + + // Add conditional header if we have an ETag + let resourceKey = url.absoluteString + if let etag = etagStorage[resourceKey] { + request.addValue(etag, forHTTPHeaderField: "If-None-Match") + } + + let (data, response) = try await URLSession.shared.data(for: request) + guard let httpResponse = response as? HTTPURLResponse else { + throw APIError.invalidResponse + } + + // Store ETag if present + if let newETag = httpResponse.value(forHTTPHeaderField: "ETag") { + etagStorage[resourceKey] = newETag + } + + if httpResponse.statusCode == 304 { + // Resource not modified, return cached data + guard let cachedData = try PersistentCache().getData(forKey: resourceKey) else { + throw APIError.cacheInconsistency + } + return cachedData + } else if (200..<300).contains(httpResponse.statusCode) { + // New or modified data + try PersistentCache().cacheData(data, forKey: resourceKey, expirationInterval: 3600) + return data + } else { + throw APIError.httpError(httpResponse.statusCode) + } + } +} +``` + +## Optimizing Data Transfers + +### Compression + +The Registry API supports gzip compression. Enable it in your requests: + +```swift +var request = URLRequest(url: url) +request.addValue("gzip, deflate", forHTTPHeaderField: "Accept-Encoding") +``` + +### Request Only What You Need + +Use query parameters to limit the data you retrieve: + +```swift +// Example: Limiting the number of results +func searchPackages(query: String, limit: Int = 20) async throws -> [Identifier] { + let urlString = "https://registry.example.com/identifiers?query=\(query)&limit=\(limit)" + guard let url = URL(string: urlString) else { + throw URLError(.badURL) + } + + let (data, _) = try await URLSession.shared.data(from: url) + return try JSONDecoder().decode([Identifier].self, from: data) +} +``` + +### Avoiding Redundant Requests + +Track in-flight requests to avoid duplicate network calls: + +```swift +class APIRequestCoordinator { + private var inFlightRequests = [URL: Task]() + private let lock = NSLock() + + func performRequest(for url: URL) async throws -> Data { + lock.lock() + + // Check if there's already an in-flight request for this URL + if let existingTask = inFlightRequests[url] { + lock.unlock() + return try await existingTask.value + } + + // Create a new task for this request + let task = Task { + defer { + lock.lock() + inFlightRequests[url] = nil + lock.unlock() + } + + let (data, _) = try await URLSession.shared.data(from: url) + return data + } + + // Store the task + inFlightRequests[url] = task + lock.unlock() + + return try await task.value + } +} +``` + +## Concurrent Operations + +### Parallel Downloads + +Download multiple packages in parallel for faster bulk operations: + +```swift +func downloadMultiplePackages(packages: [(scope: String, name: String, version: String)]) async throws -> [String: Data] { + // Create a task for each package + let tasks = packages.map { package in + Task { + let (scope, name, version) = package + let url = URL(string: "https://registry.example.com/\(scope)/\(name)/\(version).zip")! + let (data, _) = try await URLSession.shared.data(from: url) + return (key: "\(scope)/\(name)/\(version)", data: data) + } + } + + // Wait for all tasks to complete + var results = [String: Data]() + for task in tasks { + do { + let (key, data) = try await task.value + results[key] = data + } catch { + // Handle individual download failures + print("Failed to download package: \(error.localizedDescription)") + } + } + + return results +} +``` + +### Task Prioritization + +Use task priorities for critical vs. background operations: + +```swift +// High-priority task (e.g., user-initiated download) +let highPriorityTask = Task(priority: .userInitiated) { + let url = URL(string: "https://registry.example.com/\(scope)/\(name)/\(version).zip")! + return try await URLSession.shared.data(from: url) +} + +// Background task (e.g., prefetching) +let backgroundTask = Task(priority: .background) { + let url = URL(string: "https://registry.example.com/\(scope)/\(name)")! + return try await URLSession.shared.data(from: url) +} +``` + +## Network Efficiency + +### Connection Pooling + +Configure your URLSession for connection reuse: + +```swift +let configuration = URLSessionConfiguration.default +configuration.httpMaximumConnectionsPerHost = 6 // Default is 6 +configuration.timeoutIntervalForRequest = 30.0 // 30 seconds +configuration.timeoutIntervalForResource = 60.0 // 60 seconds + +let session = URLSession(configuration: configuration) +``` + +### Batch Operations + +When possible, use batch operations to reduce round trips: + +```swift +// Instead of multiple separate requests +func batchFetchIdentifiers(queries: [String]) async throws -> [String: [Identifier]] { + let queryString = queries.joined(separator: ",") + let url = URL(string: "https://registry.example.com/identifiers?queries=\(queryString)")! + + let (data, _) = try await URLSession.shared.data(from: url) + return try JSONDecoder().decode([String: [Identifier]].self, from: data) +} +``` + +## Prefetching and Predictive Loading + +Implement predictive loading for a smoother user experience: + +```swift +class PredictiveLoader { + private let prefetchQueue = OperationQueue() + private var prefetchedData = [URL: Data]() + + init() { + prefetchQueue.maxConcurrentOperationCount = 2 + prefetchQueue.qualityOfService = .utility + } + + func prefetchRelatedPackages(for package: PackageMetadata) { + guard let dependencies = package.dependencies else { return } + + for dependency in dependencies { + let dependencyURL = URL(string: "https://registry.example.com/\(dependency.scope)/\(dependency.name)")! + + Task(priority: .background) { + do { + let (data, _) = try await URLSession.shared.data(from: dependencyURL) + prefetchedData[dependencyURL] = data + } catch { + // Silently fail for prefetching + print("Failed to prefetch \(dependencyURL): \(error.localizedDescription)") + } + } + } + } + + func getPrefetchedData(for url: URL) -> Data? { + return prefetchedData[url] + } +} +``` + +## Monitoring and Analytics + +Implement performance monitoring to identify bottlenecks: + +```swift +class PerformanceMonitor { + private var requestTimings = [String: [TimeInterval]]() + private let lock = NSLock() + + func recordRequestStart(endpoint: String) -> CFAbsoluteTime { + return CFAbsoluteTimeGetCurrent() + } + + func recordRequestEnd(endpoint: String, startTime: CFAbsoluteTime) { + let duration = CFAbsoluteTimeGetCurrent() - startTime + + lock.lock() + defer { lock.unlock() } + + if requestTimings[endpoint] == nil { + requestTimings[endpoint] = [duration] + } else { + requestTimings[endpoint]?.append(duration) + } + + // Log slow requests + if duration > 1.0 { + print("⚠ī¸ Slow request to \(endpoint): \(String(format: "%.2f", duration))s") + } + } + + func getAverageResponseTime(for endpoint: String) -> TimeInterval? { + lock.lock() + defer { lock.unlock() } + + guard let timings = requestTimings[endpoint], !timings.isEmpty else { + return nil + } + + return timings.reduce(0, +) / Double(timings.count) + } + + func generatePerformanceReport() -> [String: Any] { + lock.lock() + defer { lock.unlock() } + + var report = [String: Any]() + + for (endpoint, timings) in requestTimings { + guard !timings.isEmpty else { continue } + + let avgTime = timings.reduce(0, +) / Double(timings.count) + let maxTime = timings.max() ?? 0 + let minTime = timings.min() ?? 0 + + report[endpoint] = [ + "avg": avgTime, + "min": minTime, + "max": maxTime, + "count": timings.count + ] + } + + return report + } +} +``` + +## Best Practices Summary + +1. **Implement comprehensive caching**: + - Use memory caching for frequently accessed data + - Add persistent caching for larger or less frequently changing data + - Implement conditional requests with ETags + +2. **Optimize network usage**: + - Enable compression in requests + - Limit response size with query parameters + - Deduplicate in-flight requests + +3. **Use concurrency effectively**: + - Download resources in parallel + - Prioritize user-initiated tasks + - Implement connection pooling + +4. **Implement predictive loading**: + - Prefetch likely-to-be-needed resources + - Load related packages in the background + +5. **Monitor performance**: + - Track request timings + - Identify slow operations + - Generate reports for optimization opportunities + +## See Also + +- +- diff --git a/RegistryAPI.docc/Tutorials/Publishing.md b/RegistryAPI.docc/Tutorials/Publishing.md new file mode 100644 index 00000000..4e2e74ae --- /dev/null +++ b/RegistryAPI.docc/Tutorials/Publishing.md @@ -0,0 +1,92 @@ +# Publishing Packages + +Learn how to publish your Swift packages to a package registry. + +## Overview + +Publishing your Swift package to a registry makes it easily accessible to others and enables versioning and dependency management. This guide walks you through the process of preparing and publishing a package. + +## Preparing Your Package + +Before publishing, ensure your package is properly configured: + +1. Verify your Package.swift file has correct metadata: + ```swift + // swift-tools-version: 5.7 + import PackageDescription + + let package = Package( + name: "MyLibrary", + platforms: [.macOS(.v12), .iOS(.v15)], + products: [ + .library(name: "MyLibrary", targets: ["MyLibrary"]), + ], + dependencies: [], + targets: [ + .target(name: "MyLibrary"), + .testTarget(name: "MyLibraryTests", dependencies: ["MyLibrary"]), + ] + ) + ``` + +2. Make sure your version tags follow [Semantic Versioning](https://semver.org/) (e.g., `1.0.0`, `1.2.3`) + +3. Include a LICENSE file and README.md with clear documentation + +## Publishing a New Version + +To publish a new version of your package: + +```swift +// Create a zip archive of your package +let packageData = createPackageZipArchive() // Implementation depends on your tooling + +// Set the authentication token +let authToken = "your-auth-token" // See Authentication guide +let packageScope = "mona" +let packageName = "MyLibrary" +let version = "1.0.0" + +// Create publish URL +let publishURL = URL(string: "https://registry.example.com/\(packageScope)/\(packageName)/\(version)")! +var request = URLRequest(url: publishURL) +request.httpMethod = "PUT" +request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type") +request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization") +request.setValue("sha256=\(calculateSHA256(packageData))", forHTTPHeaderField: "X-Swift-Package-Signature") + +// Set the package data +request.httpBody = packageData + +// Send request +let (responseData, response) = try await URLSession.shared.data(for: request) + +// Check response status +if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 201 { + print("Package version published successfully!") +} +``` + +## Handling Responses + +The registry returns specific status codes: + +| Status Code | Meaning | +|-------------|---------| +| 201 | Created - version published successfully | +| 202 | Accepted - version queued for processing | +| 409 | Conflict - version already exists | +| 422 | Unprocessable - invalid package | + +## Version Management + +When publishing versions: + +- Once a version is published, it cannot be changed +- You can publish new versions with increasing version numbers +- Follow semantic versioning guidelines for compatibility + +## Next Steps + +- Explore endpoint details for more information on the publishing process +- Learn about managing package releases and metadata diff --git a/RegistryAPI.docc/Tutorials/RateLimiting.md b/RegistryAPI.docc/Tutorials/RateLimiting.md new file mode 100644 index 00000000..0f209e82 --- /dev/null +++ b/RegistryAPI.docc/Tutorials/RateLimiting.md @@ -0,0 +1,263 @@ +# Rate Limiting + +Learn about the Swift Package Registry's rate limiting mechanisms and how to optimize your usage. + +## Overview + +The Swift Package Registry API implements rate limiting to ensure fair usage and system stability. Understanding these limits and implementing proper handling will improve your application's reliability when interacting with the registry. + +## Rate Limiting Headers + +When you make requests to the API, the following headers are included in every response: + +| Header | Description | +|--------|-------------| +| `RateLimit-Limit` | Maximum number of requests allowed in the current time window | +| `RateLimit-Remaining` | Number of requests remaining in the current time window | +| `RateLimit-Reset` | Time when the current rate limit window resets (UTC epoch seconds) | + +```swift +// Example: Checking rate limiting headers +func checkRateLimits(from response: HTTPURLResponse) -> RateLimitInfo { + let limit = Int(response.value(forHTTPHeaderField: "RateLimit-Limit") ?? "60") ?? 60 + let remaining = Int(response.value(forHTTPHeaderField: "RateLimit-Remaining") ?? "0") ?? 0 + let resetTime = TimeInterval(response.value(forHTTPHeaderField: "RateLimit-Reset") ?? "0") ?? 0 + + return RateLimitInfo( + limit: limit, + remaining: remaining, + resetDate: Date(timeIntervalSince1970: resetTime) + ) +} +``` + +## Rate Limit Tiers + +The API has different rate limit tiers depending on your authentication status: + +| Tier | Requests per Hour | Description | +|------|-------------------|-------------| +| Anonymous | 60 | Unauthenticated requests | +| Authenticated | 1,000 | Requests with a valid user token | +| Service | 5,000 | Requests with a service token | + +## Handling Rate Limiting + +When you exceed your rate limit, the API responds with a `429 Too Many Requests` status code and includes a `Retry-After` header indicating how many seconds to wait before retrying. + +```swift +// Example: Rate limit handling with backoff +func makeRegistryRequest(_ request: URLRequest) async throws -> Data { + let session = URLSession.shared + + do { + let (data, response) = try await session.data(for: request) + guard let httpResponse = response as? HTTPURLResponse else { + throw RegistryError.invalidResponse + } + + if httpResponse.statusCode == 429 { + // We hit a rate limit + if let retryAfterString = httpResponse.value(forHTTPHeaderField: "Retry-After"), + let retryAfter = TimeInterval(retryAfterString) { + + // Wait for the specified time before retrying + try await Task.sleep(nanoseconds: UInt64(retryAfter * 1_000_000_000)) + + // Retry the request + return try await makeRegistryRequest(request) + } else { + throw RegistryError.rateLimitExceeded + } + } + + // Handle other status codes... + + return data + } catch { + // Handle network errors + throw error + } +} +``` + +## Best Practices + +### 1. Monitor Your Usage + +Always check rate limit headers and keep track of your consumption to avoid hitting limits: + +```swift +class RegistryClient { + private var rateLimitInfo: RateLimitInfo? + + func updateRateLimitInfo(from response: HTTPURLResponse) { + rateLimitInfo = checkRateLimits(from: response) + + // Log when close to limit + if let info = rateLimitInfo, info.remaining < info.limit * 0.1 { + print("Warning: Rate limit nearly reached. \(info.remaining) requests remaining until \(info.resetDate)") + } + } + + // Other methods... +} +``` + +### 2. Implement Caching + +Reduce your API calls by caching responses appropriately: + +```swift +class RegistryClient { + private var cache = NSCache() + + func fetchPackageMetadata(scope: String, name: String) async throws -> PackageMetadata { + let cacheKey = "\(scope)/\(name)" as NSString + + // Check cache first + if let cachedResponse = cache.object(forKey: cacheKey), + cachedResponse.expirationDate > Date() { + return cachedResponse.metadata + } + + // Make API request + let url = URL(string: "https://registry.example.com/\(scope)/\(name)")! + let (data, response) = try await URLSession.shared.data(from: url) + + // Update rate limit info + if let httpResponse = response as? HTTPURLResponse { + updateRateLimitInfo(from: httpResponse) + } + + // Parse and cache response + let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) + + // Cache for 5 minutes + let cachedResponse = CachedResponse( + metadata: metadata, + expirationDate: Date().addingTimeInterval(5 * 60) + ) + cache.setObject(cachedResponse, forKey: cacheKey) + + return metadata + } +} +``` + +### 3. Use Conditional Requests + +When appropriate, use ETag or Last-Modified headers to make conditional requests: + +```swift +func fetchPackageWithETag(scope: String, name: String) async throws -> PackageMetadata { + let url = URL(string: "https://registry.example.com/\(scope)/\(name)")! + var request = URLRequest(url: url) + + // Add ETag if we have it + if let etag = etagStorage["\(scope)/\(name)"] { + request.addValue(etag, forHTTPHeaderField: "If-None-Match") + } + + let (data, response) = try await URLSession.shared.data(for: request) + guard let httpResponse = response as? HTTPURLResponse else { + throw RegistryError.invalidResponse + } + + // Update rate limit info + updateRateLimitInfo(from: httpResponse) + + // Store new ETag if present + if let newETag = httpResponse.value(forHTTPHeaderField: "ETag") { + etagStorage["\(scope)/\(name)"] = newETag + } + + // If 304 Not Modified, return cached data + if httpResponse.statusCode == 304 { + guard let cachedMetadata = metadataCache["\(scope)/\(name)"] else { + throw RegistryError.cacheInconsistency + } + return cachedMetadata + } + + // Process new data + let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data) + metadataCache["\(scope)/\(name)"] = metadata + return metadata +} +``` + +### 4. Batch Requests When Possible + +Instead of making multiple small requests, batch them when the API supports it: + +```swift +// Instead of fetching packages one by one +func fetchMultiplePackageIdentifiers(query: String) async throws -> [Identifier] { + // Use the search endpoint with multiple criteria + let url = URL(string: "https://registry.example.com/identifiers?query=\(query)&limit=100")! + let (data, response) = try await URLSession.shared.data(from: url) + + if let httpResponse = response as? HTTPURLResponse { + updateRateLimitInfo(from: httpResponse) + } + + return try JSONDecoder().decode([Identifier].self, from: data) +} +``` + +### 5. Queue and Prioritize Requests + +When working with many requests, implement a queue system that respects rate limits: + +```swift +class RegistryRequestQueue { + private var queue = [RegistryRequest]() + private var isProcessing = false + + func addRequest(_ request: RegistryRequest) { + queue.append(request) + processQueue() + } + + private func processQueue() { + guard !isProcessing, !queue.isEmpty else { return } + + isProcessing = true + + Task { + repeat { + // Sort queue by priority + queue.sort { $0.priority > $1.priority } + + // Take the next request + let nextRequest = queue.removeFirst() + + do { + let _ = try await executeRequest(nextRequest) + // Handle success + await nextRequest.completion(.success(())) + } catch { + // Handle error + await nextRequest.completion(.failure(error)) + + if let registryError = error as? RegistryError, + case .rateLimitExceeded = registryError { + // Wait before continuing if rate limited + try? await Task.sleep(nanoseconds: 5_000_000_000) + } + } + } while !queue.isEmpty + + isProcessing = false + } + } + + // Other methods... +} +``` + +## See Also + +- +- diff --git a/RegistryAPI.docc/Tutorials/Security.md b/RegistryAPI.docc/Tutorials/Security.md new file mode 100644 index 00000000..829b8f3c --- /dev/null +++ b/RegistryAPI.docc/Tutorials/Security.md @@ -0,0 +1,364 @@ +# Security Best Practices + +Learn how to securely interact with the Swift Package Registry API. + +## Overview + +Security is a critical aspect of package management. This guide covers best practices for securely interacting with the Swift Package Registry API, protecting sensitive information, and verifying package authenticity. + +## Secure Authentication + +### Token Management + +When working with authentication tokens: + +- **Never hardcode tokens** in your application source code +- Use environment variables, secure storage, or a secrets management solution +- Rotate tokens regularly following the principle of least privilege +- Set appropriate token expiration times + +```swift +// ❌ INCORRECT: Hardcoded token +let apiToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." + +// ✅ BETTER: Load from secure storage +let apiToken = try KeychainManager.getToken(forService: "registry-api") + +// ✅ BEST: Use a token provider with automatic rotation +let apiToken = try await TokenProvider.shared.getValidToken() +``` + +### Secure Token Storage + +Store your tokens securely using platform-appropriate mechanisms: + +```swift +// Example: Secure token storage using keychain on Apple platforms +class KeychainTokenStorage: TokenStorage { + func saveToken(_ token: String, forService service: String) throws { + let query: [String: Any] = [ + kSecClass as String: kSecClassGenericPassword, + kSecAttrService as String: service, + kSecAttrAccount as String: "api-token", + kSecValueData as String: Data(token.utf8), + kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly + ] + + // Delete any existing token + SecItemDelete(query as CFDictionary) + + // Save the new token + let status = SecItemAdd(query as CFDictionary, nil) + guard status == errSecSuccess else { + throw TokenStorageError.saveFailed(status) + } + } + + func getToken(forService service: String) throws -> String { + let query: [String: Any] = [ + kSecClass as String: kSecClassGenericPassword, + kSecAttrService as String: service, + kSecAttrAccount as String: "api-token", + kSecReturnData as String: true, + kSecMatchLimit as String: kSecMatchLimitOne + ] + + var result: AnyObject? + let status = SecItemCopyMatching(query as CFDictionary, &result) + + guard status == errSecSuccess else { + throw TokenStorageError.retrievalFailed(status) + } + + guard let tokenData = result as? Data, + let token = String(data: tokenData, encoding: .utf8) else { + throw TokenStorageError.invalidData + } + + return token + } +} +``` + +## Package Integrity Verification + +Always verify package integrity using the provided checksums: + +```swift +// Example: Verify package checksum +func verifyPackageIntegrity(packageData: Data, expectedChecksum: String) throws -> Bool { + // Calculate the SHA-256 hash of the package data + let computedHash = SHA256.hash(data: packageData) + let computedChecksum = computedHash.compactMap { String(format: "%02x", $0) }.joined() + + // Compare with the expected checksum (case-insensitive) + return computedChecksum.lowercased() == expectedChecksum.lowercased() +} + +// Usage example +func downloadAndVerifyPackage(scope: String, name: String, version: String) async throws -> Data { + // 1. Get package metadata with checksum information + let metadataURL = URL(string: "https://registry.example.com/\(scope)/\(name)/\(version)")! + let (metadataData, _) = try await URLSession.shared.data(from: metadataURL) + let release = try JSONDecoder().decode(ReleaseResource.self, from: metadataData) + + // 2. Find the source archive resource and its checksum + guard let sourceArchive = release.resources.first(where: { $0.name == "source-archive" }), + let checksum = sourceArchive.checksum else { + throw VerificationError.missingChecksumInfo + } + + // 3. Download the package + let packageURL = URL(string: "https://registry.example.com/\(scope)/\(name)/\(version).zip")! + let (packageData, _) = try await URLSession.shared.data(from: packageURL) + + // 4. Verify the integrity + guard try verifyPackageIntegrity(packageData: packageData, expectedChecksum: checksum) else { + throw VerificationError.checksumMismatch + } + + return packageData +} +``` + +## Transport Security + +Always use secure connections when communicating with the registry: + +- Ensure your URL connections use HTTPS +- Verify TLS certificates +- Enable certificate pinning for critical applications + +```swift +// Example: URL Session configuration with certificate pinning +func createSecureURLSession() -> URLSession { + let configuration = URLSessionConfiguration.default + + // Ensure only HTTPS connections are allowed + configuration.tlsMinimumSupportedProtocolVersion = .TLSv12 + + // Create a delegate for certificate pinning + let delegate = CertificatePinningDelegate() + + return URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil) +} + +class CertificatePinningDelegate: NSObject, URLSessionDelegate { + func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, + completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) { + + guard let serverTrust = challenge.protectionSpace.serverTrust, + challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust, + challenge.protectionSpace.host.hasSuffix("registry.example.com") else { + // Reject invalid challenges + completionHandler(.cancelAuthenticationChallenge, nil) + return + } + + // Get the server's certificate data + let serverCertificatesData = certificateData(for: serverTrust) + + // Get the pinned certificate data + guard let pinnedCertificateData = loadPinnedCertificateData() else { + completionHandler(.cancelAuthenticationChallenge, nil) + return + } + + // Compare certificates + if serverCertificatesData.contains(pinnedCertificateData) { + // Certificate matched, proceed with connection + let credential = URLCredential(trust: serverTrust) + completionHandler(.useCredential, credential) + } else { + // Certificate mismatch, cancel connection + completionHandler(.cancelAuthenticationChallenge, nil) + } + } + + // Helper methods... +} +``` + +## Secure Dependency Resolution + +Follow these guidelines when resolving package dependencies: + +1. **Define exact versions** when possible to prevent unexpected changes +2. **Use package checksums** to validate package integrity during resolution +3. **Lock dependencies** in your Package.resolved file +4. **Audit dependencies** regularly for vulnerabilities + +```swift +// Example: Package.swift with pinned dependencies +dependencies: [ + .package( + url: "https://github.com/apple/swift-algorithms", + exact: "1.0.0" // Pin to exact version + ), + .package( + url: "https://github.com/apple/swift-collections", + revision: "a281e8b846a354fca484a08abbc657dfe39c9b1c" // Pin to specific commit + ) +] +``` + +## Content Security + +### XSS Protection + +When displaying package metadata or README content in your application: + +1. Always sanitize content before rendering +2. Use a secure rendering library that handles escaping +3. Consider Content Security Policy (CSP) for web applications + +```swift +// Example: Content sanitization for package metadata +func sanitizeHTMLContent(_ html: String) -> String { + // Use a proper HTML sanitizer library here + // This is a simplified example + let disallowedTags = ["script", "iframe", "object", "embed"] + + var sanitized = html + for tag in disallowedTags { + let openTagPattern = "<\(tag)[^>]*>" + let closeTagPattern = "" + + sanitized = sanitized.replacingOccurrences(of: openTagPattern, + with: "", + options: .regularExpression) + sanitized = sanitized.replacingOccurrences(of: closeTagPattern, + with: "", + options: .regularExpression) + } + + return sanitized +} +``` + +### Input Validation + +Always validate input parameters before sending them to the API: + +```swift +// Example: Parameter validation +func validatePackageParameters(scope: String, name: String, version: String?) throws { + // Validate scope + guard scope.range(of: "^[a-zA-Z0-9][-a-zA-Z0-9_.]*$", options: .regularExpression) != nil else { + throw ValidationError.invalidScope + } + + // Validate name + guard name.range(of: "^[a-zA-Z0-9][-a-zA-Z0-9_.]*$", options: .regularExpression) != nil else { + throw ValidationError.invalidName + } + + // Validate version if provided + if let version = version { + guard version.range(of: "^\\d+\\.\\d+\\.\\d+$", options: .regularExpression) != nil else { + throw ValidationError.invalidVersion + } + } +} +``` + +## Additional Security Measures + +### API Key Rotation + +Implement regular key rotation to minimize risk: + +```swift +// Example: Token rotation schedule +class TokenRotationManager { + private let tokenStorage: TokenStorage + private let tokenProvider: TokenProvider + + // Rotate tokens every 30 days + private let rotationInterval: TimeInterval = 30 * 24 * 60 * 60 + + func scheduleRotation() { + // Check when the current token was created + let currentTokenCreationDate = tokenStorage.getTokenCreationDate() + + // Calculate time until next rotation + let timeUntilRotation = max(0, + (currentTokenCreationDate.addingTimeInterval(rotationInterval).timeIntervalSince1970 - + Date().timeIntervalSince1970)) + + // Schedule rotation + DispatchQueue.global().asyncAfter(deadline: .now() + timeUntilRotation) { [weak self] in + self?.rotateToken() + } + } + + private func rotateToken() { + do { + // Generate new token + let newToken = try tokenProvider.generateNewToken() + + // Save the new token + try tokenStorage.saveToken(newToken) + + // Revoke the old token + try tokenProvider.revokeToken(tokenStorage.getOldToken()) + + // Schedule the next rotation + scheduleRotation() + } catch { + // Handle rotation failure + // Log error and retry after a short delay + } + } +} +``` + +### Logging and Monitoring + +Implement secure logging practices: + +- Never log sensitive information such as tokens or private package data +- Use structured logging for easy analysis +- Implement monitoring for unusual access patterns + +```swift +// Example: Secure logging +enum LogLevel: String { + case debug, info, warning, error +} + +class SecureLogger { + static func log(_ message: String, level: LogLevel = .info, sensitiveData: Bool = false) { + // Don't log sensitive data in production + #if DEBUG + let logEntry = "[\(level.rawValue.uppercased())] \(Date()): \(message)" + print(logEntry) + #else + if !sensitiveData { + let logEntry = "[\(level.rawValue.uppercased())] \(Date()): \(message)" + print(logEntry) + // In a real implementation, send to logging service + } + #endif + } + + static func logAPIRequest(endpoint: String, statusCode: Int?, error: Error?) { + var message = "API Request: \(endpoint)" + + if let statusCode = statusCode { + message += ", Status: \(statusCode)" + } + + if let error = error { + message += ", Error: \(error.localizedDescription)" + } + + log(message) + } +} +``` + +## See Also + +- +- diff --git a/Sources/CLI/main.swift b/Sources/CLI/main.swift index 185219f9..2ffe7930 100644 --- a/Sources/CLI/main.swift +++ b/Sources/CLI/main.swift @@ -1,62 +1,92 @@ import Foundation import ArgumentParser -import OpenAPItoSymbolGraph -import Integration import OpenAPI +import DocC +import SymbolKit +import OpenAPItoSymbolGraph -struct OpenAPIToSymbolGraph: ParsableCommand { +/// Command for converting OpenAPI documents to DocC symbol graphs +struct OpenAPItoDocC: ParsableCommand { static var configuration = CommandConfiguration( - commandName: "openapi-to-symbolgraph", - abstract: "Convert OpenAPI specifications to DocC symbol graphs", + commandName: "openapi-to-docc", + abstract: "Convert OpenAPI documents to DocC symbol graphs", version: "1.0.0" ) - @Argument(help: "Path to the OpenAPI specification file") - var inputPath: String + @Argument(help: "The path to the OpenAPI document (YAML or JSON)") + var input: String + + @Option(name: .shortAndLong, help: "The output directory for the symbol graph file") + var output: String = "." - @Option(name: .long, help: "Path where the symbol graph file should be written", transform: { $0 }) - var outputPath: String = "openapi.symbolgraph.json" + @Option(name: .customLong("output-path"), help: "Alternative name for output directory") + var outputPath: String? - @Option(name: .long, help: "Name to use for the module in the symbol graph", transform: { $0 }) + @Option(name: .shortAndLong, help: "The name for the module") var moduleName: String? - @Option(name: .long, help: "Base URL of the API for HTTP endpoint documentation", transform: { URL(string: $0) }) - var baseURL: URL? + @Option(name: .long, help: "The base URL for the API") + var baseURL: String? mutating func run() throws { - // Check file extension - let fileExtension = URL(fileURLWithPath: inputPath).pathExtension.lowercased() - guard fileExtension == "yaml" || fileExtension == "yml" || fileExtension == "json" else { - throw ConversionError.unsupportedFileType(fileExtension) + // Use outputPath if provided as alternative to output + let finalOutput = outputPath ?? output + + // 1. Determine if input is YAML or JSON + let inputURL = URL(fileURLWithPath: input) + let fileExtension = inputURL.pathExtension.lowercased() + + // 2. Parse the document + print("Parsing OpenAPI document: \(input)") + let document: OpenAPI.Document + + do { + if fileExtension == "yaml" || fileExtension == "yml" { + let parser = OpenAPI.YAMLParser() + document = try parser.parse(fileURL: inputURL) + } else if fileExtension == "json" { + let parser = OpenAPI.JSONParser() + document = try parser.parse(fileURL: inputURL) + } else { + throw ValidationError("Unsupported file format. Please provide a YAML or JSON file.") + } + } catch { + print("Error parsing OpenAPI document: \(error)") + throw ValidationError("Failed to parse OpenAPI document") + } + + // 3. Generate the symbol graph + print("Generating symbol graph...") + var baseURLObj: URL? + if let baseURLString = baseURL { + baseURLObj = URL(string: baseURLString) } - // Read the OpenAPI file - let inputURL = URL(fileURLWithPath: inputPath) - let outputURL = URL(fileURLWithPath: outputPath) + var generator = DocC.SymbolGraphGenerator( + moduleName: moduleName ?? document.info.title, + baseURL: baseURLObj + ) + + let symbolGraph = generator.generate(from: document) + + // 4. Write the symbol graph to a file + let outputFileName = (moduleName ?? document.info.title.replacingOccurrences(of: " ", with: "")) + ".symbols.json" + let outputURL = URL(fileURLWithPath: finalOutput).appendingPathComponent(outputFileName) + + print("Writing symbol graph to: \(outputURL.path)") - // Read the file content - let fileContent = try String(contentsOf: inputURL, encoding: .utf8) + let encoder = JSONEncoder() + encoder.outputFormatting = [.prettyPrinted, .sortedKeys] - // Parse the OpenAPI document - let parser = YAMLParser() do { - let document = try parser.parse(fileContent) - - // Convert to symbol graph - let converter = Integration.OpenAPIDocCConverter(moduleName: moduleName, baseURL: baseURL) - let symbolGraph = converter.convert(document) - - // Write the symbol graph to file - let encoder = JSONEncoder() - encoder.outputFormatting = [.prettyPrinted, .sortedKeys] - let jsonData = try encoder.encode(symbolGraph) - try jsonData.write(to: outputURL) - - print("Successfully generated symbol graph at \(outputPath)") - } catch let error as ParserError { - throw ConversionError.parsingError(error) + let data = try encoder.encode(symbolGraph) + try data.write(to: outputURL) + print("Symbol graph successfully written to \(outputURL.path)") + } catch { + print("Error writing symbol graph: \(error)") + throw ValidationError("Failed to write symbol graph") } } } -OpenAPIToSymbolGraph.main() +OpenAPItoDocC.main() diff --git a/Sources/DocC/Generators/SymbolGraphGenerator.swift b/Sources/DocC/Generators/SymbolGraphGenerator.swift index 9f49c7eb..d9af2372 100644 --- a/Sources/DocC/Generators/SymbolGraphGenerator.swift +++ b/Sources/DocC/Generators/SymbolGraphGenerator.swift @@ -15,12 +15,81 @@ public struct SymbolGraphGenerator { self.baseURL = baseURL } + /// Helper to resolve references in OpenAPI documents + /// Use a private dictionary to cache resolved references to avoid redundant lookups and infinite loops + private var resolvedReferences: [String: Any] = [:] + + /// A helper function to resolve a reference if the provided value is a reference type + /// Note: This is a generic approach since we don't know the exact structure of the custom Reference type + private mutating func resolveReference(_ value: Any, in document: Document) -> T? { + // First check if it's already a properly typed value (not a reference) + if let directValue = value as? T { + return directValue + } + + // Try to handle if it's a reference + // We have to use reflection or runtime checks since we don't know exact structure + // This is a simplified approach - would need adjustment based on actual model structure + // Try to access a 'ref' property or Reference type through mirrors + let mirror = Mirror(reflecting: value) + + // Look for a 'ref' property - common in OpenAPI reference implementations + // Or check if it conforms to a custom Reference protocol + if let refProp = mirror.children.first(where: { $0.label == "ref" })?.value as? String { + // If we've already resolved this reference, return the cached result + if let cached = resolvedReferences[refProp] as? T { + return cached + } + + // Parse the reference string - typically in format "#/components/[type]/[name]" + let parts = refProp.split(separator: "/") + guard parts.count >= 3, parts[1] == "components" else { + print("Warning: Invalid reference format: \(refProp)") + return nil + } + + let componentType = String(parts[2]) + let componentName = String(parts[3]) + + // Get the appropriate component collection based on type + var component: Any? + switch componentType { + case "schemas": + component = document.components?.schemas?[componentName] + case "parameters": + component = document.components?.parameters?[componentName] + // Note: The custom Components structure might not have all standard OpenAPI components + // Let's simplify and only include what we've seen in the model so far + case "responses", "requestBodies", "examples", "headers", "securitySchemes", "links", "callbacks": + // Custom OpenAPI model might not have all standard components + // Skip these for now, or implement when needed + print("Warning: Component type '\(componentType)' might not be supported yet") + default: + print("Warning: Unsupported component type: \(componentType)") + return nil + } + + // Recursively resolve the component if it's also a reference + if let resolvedComponent = component { + if let result = self.resolveReference(resolvedComponent, in: document) as T? { + // Cache the result to avoid redundant resolutions + self.resolvedReferences[refProp] = result + return result + } + } + } + + // If we can't determine it's a reference or can't resolve it + print("Warning: Could not resolve reference") + return nil + } + /// Generates a symbol graph from an OpenAPI document /// - Parameter document: The OpenAPI document to convert /// - Returns: The generated symbol graph - public func generate(from document: Document) -> SymbolKit.SymbolGraph { - // For now, we'll skip the mixin registration as it requires more work to implement correctly - // We're still generating valid symbol graphs, just without the HTTP-specific enhancements + public mutating func generate(from document: Document) -> SymbolKit.SymbolGraph { + // Clear the references cache for a fresh generation + self.resolvedReferences = [:] var symbols: [SymbolKit.SymbolGraph.Symbol] = [] var relationships: [SymbolKit.SymbolGraph.Relationship] = [] @@ -29,82 +98,137 @@ public struct SymbolGraphGenerator { let moduleSymbol = createModuleSymbol(from: document.info) symbols.append(moduleSymbol) - // Add path symbols - for (path, pathItem) in document.paths { - // Add path symbol - let pathSymbol = createPathSymbol(path: path, pathItem: pathItem) + // Process path items + for (pathString, pathItemValue) in document.paths { + // Handle potential reference or direct value + // We can't make assumptions about the exact type, so use our helper + guard let pathItem = self.resolveReference(pathItemValue, in: document) as PathItem? else { + print("Warning: Could not process path item at \(pathString) - may be an unresolvable reference") + continue + } + + // Create path symbol + let pathSymbol = createPathSymbol(path: pathString, pathItem: pathItem) symbols.append(pathSymbol) // Add relationship from module to path relationships.append(SymbolKit.SymbolGraph.Relationship( - source: moduleSymbol.identifier.precise, - target: pathSymbol.identifier.precise, + source: pathSymbol.identifier.precise, + target: moduleSymbol.identifier.precise, kind: .memberOf, - targetFallback: path + targetFallback: pathString )) - // Add operation symbols + // Process operations for (method, operation) in pathItem.allOperations() { - // Add operation symbol - let operationSymbol = createOperationSymbol(method: method, operation: operation, path: path) + // Create operation symbol + let operationSymbol = createOperationSymbol(method: method, operation: operation, path: pathString) symbols.append(operationSymbol) - // Add relationship from path to operation + // Add relationship from operation to path relationships.append(SymbolKit.SymbolGraph.Relationship( source: operationSymbol.identifier.precise, target: pathSymbol.identifier.precise, kind: .memberOf, - targetFallback: "\(method.rawValue.uppercased()) \(path)" + targetFallback: "\(method.rawValue.uppercased()) \(pathString)" )) - // Add parameter symbols + // Process parameters if let parameters = operation.parameters { - for parameter in parameters { - // Add parameter symbol + for parameterValue in parameters { + // Resolve parameter reference if needed + guard let parameter = self.resolveReference(parameterValue, in: document) as Parameter? else { + print("Warning: Could not process parameter - may be an unresolvable reference") + continue + } + let parameterSymbol = createParameterSymbol(parameter: parameter, operation: operationSymbol) symbols.append(parameterSymbol) - // Add relationship from operation to parameter + // Add relationship from parameter to operation relationships.append(SymbolKit.SymbolGraph.Relationship( source: parameterSymbol.identifier.precise, target: operationSymbol.identifier.precise, kind: .memberOf, targetFallback: parameter.name )) + + // If parameter has a schema, add a relationship to it + self.processSchemaReference(parameter.schema, fromSource: parameterSymbol.identifier.precise, inSymbols: &symbols, inRelationships: &relationships) } } - // Add response symbols - for (statusCode, response) in operation.responses { - // Add response symbol + // Process request body if present + if let requestBody = operation.requestBody { + // Handle potential reference + if let _: RequestBody = self.resolveReference(requestBody, in: document) { + // TODO: Create request body symbol and relationships + // For now just print that we'd process it + print("Would process request body for \(method.rawValue.uppercased()) \(pathString)") + } + } + + // Process responses + for (statusCode, responseValue) in operation.responses { + // Resolve response reference if needed + guard let response = self.resolveReference(responseValue, in: document) as Response? else { + print("Warning: Could not process response \(statusCode) - may be an unresolvable reference") + continue + } + let responseSymbol = createResponseSymbol(statusCode: statusCode, response: response, operation: operationSymbol) symbols.append(responseSymbol) - // Add relationship from operation to response + // Add relationship from response to operation relationships.append(SymbolKit.SymbolGraph.Relationship( source: responseSymbol.identifier.precise, target: operationSymbol.identifier.precise, kind: .memberOf, targetFallback: statusCode )) + + // If response has content with schemas, add relationships + if let content = response.content { + for (_, mediaTypeObject) in content { + // Process response schema + self.processSchemaReference(mediaTypeObject.schema, fromSource: responseSymbol.identifier.precise, inSymbols: &symbols, inRelationships: &relationships) + } + } } } } - // Add schema symbols - if let components = document.components, let schemas = components.schemas { - for (name, schema) in schemas { - // Add schema symbol + // Process component schemas + if let components = document.components, let schemaMap = components.schemas { + for (name, schemaValue) in schemaMap { + // Resolve schema reference if needed + guard let schema = self.resolveReference(schemaValue, in: document) as JSONSchema? else { + print("Warning: Could not process schema \(name) - may be an unresolvable reference") + continue + } + let schemaSymbol = createSchemaSymbol(name: name, schema: schema) symbols.append(schemaSymbol) - // Add relationship from module to schema + // Add relationship from schema to module relationships.append(SymbolKit.SymbolGraph.Relationship( source: schemaSymbol.identifier.precise, target: moduleSymbol.identifier.precise, kind: .memberOf, targetFallback: name )) + + // Process schema properties for object schemas + if case .object(let objectSchema) = schema { + let properties = objectSchema.properties + for (_, propSchema) in properties { + // Create property symbols and relationships + // This would be expanded in a more complete implementation + + // For now, just check if the property schema references another schema + self.processSchemaReference(propSchema, fromSource: schemaSymbol.identifier.precise, inSymbols: &symbols, inRelationships: &relationships) + } + } } } @@ -116,6 +240,36 @@ public struct SymbolGraphGenerator { ) } + /// Helper to extract a schema reference name if this schema is a reference + private func getSchemaReference(_ schema: JSONSchema) -> String? { + if case .reference(let reference) = schema { + // Extract the component name from the reference string + let refString = reference.ref + let parts = refString.split(separator: "/") + guard parts.count >= 4, parts[1] == "components", parts[2] == "schemas" else { + return nil + } + return String(parts[3]) + } + return nil + } + + /// Process a schema, handling references if found, and creating appropriate relationships + private func processSchemaReference(_ schema: JSONSchema, fromSource sourceId: String, inSymbols symbols: inout [SymbolKit.SymbolGraph.Symbol], inRelationships relationships: inout [SymbolKit.SymbolGraph.Relationship]) { + // Try to identify if this is a reference to a component schema + if let schemaRef = self.getSchemaReference(schema) { + let schemaId = "schema:\(schemaRef)" + relationships.append(SymbolKit.SymbolGraph.Relationship( + source: sourceId, + target: schemaId, + kind: .requirementOf, // Standard relationship kind + targetFallback: schemaRef + )) + } + + // Could expand this to create inline schema symbols for complex non-reference schemas + } + private func createModuleSymbol(from info: Info) -> SymbolKit.SymbolGraph.Symbol { let moduleName = self.moduleName ?? info.title let identifier = SymbolKit.SymbolGraph.Symbol.Identifier( @@ -173,24 +327,76 @@ public struct SymbolGraphGenerator { } private func createOperationSymbol(method: HTTPMethod, operation: OpenAPI.Operation, path: String) -> SymbolKit.SymbolGraph.Symbol { - let title = "\(method.rawValue.uppercased()) \(path)" + let title = operation.summary ?? "\(method.rawValue.uppercased()) \(path)" let identifier = SymbolKit.SymbolGraph.Symbol.Identifier( precise: "operation:\(method.rawValue):\(path)", interfaceLanguage: "openapi" ) + // Create a better navigator display with method + path + let methodDisplay = method.rawValue.uppercased() + let navigationText = "\(methodDisplay) \(path)" + let names = SymbolKit.SymbolGraph.Symbol.Names( title: title, - navigator: [.init(kind: .text, spelling: title, preciseIdentifier: nil)], - subHeading: nil, + navigator: [.init(kind: .text, spelling: navigationText, preciseIdentifier: nil)], + subHeading: [.init(kind: .text, spelling: methodDisplay, preciseIdentifier: nil)], prose: nil ) var docComment: SymbolKit.SymbolGraph.LineList? = nil - if let description = operation.description { - let line = SymbolKit.SymbolGraph.LineList.Line(text: description, range: nil) - docComment = SymbolKit.SymbolGraph.LineList([line]) + // Improved documentation that includes more details about the operation + var docLines: [String] = [] + + // Add description if available + if let description = operation.description, !description.isEmpty { + docLines.append(description) + docLines.append("") // Add empty line after description + } + + // Add parameter summary if available + if let parameters = operation.parameters, !parameters.isEmpty { + docLines.append("**Parameters:**") + for parameter in parameters { + let required = parameter.required ? "Required" : "Optional" + // Note: access schema description if parameter description is not available + let paramDesc = parameter.schema.description ?? "" + docLines.append("- `\(parameter.name)` (\(parameter.in), \(required)): \(paramDesc)") + } + docLines.append("") // Add empty line after parameters + } + + // Add request body summary if available + if let requestBody = operation.requestBody { + docLines.append("**Request Body:**") + // Note: the RequestBody might not have a description property in our custom model + // Access content-specific information instead + let content = requestBody.content + for (mediaType, mediaTypeObject) in content { + docLines.append("Content Type: `\(mediaType)`") + docLines.append(mediaTypeObject.schema.description ?? "") + } + docLines.append("") // Add empty line after request body + } + + // Add response summary if available + if !operation.responses.isEmpty { + docLines.append("**Responses:**") + for (statusCode, response) in operation.responses { + docLines.append("- `\(statusCode)`: \(response.description)") + } + } + + // Add deprecated notice if applicable + if operation.deprecated { + docLines.insert("**⚠ī¸ Deprecated**", at: 0) + docLines.insert("", at: 1) // Empty line after deprecated notice + } + + if !docLines.isEmpty { + let lines = docLines.map { SymbolKit.SymbolGraph.LineList.Line(text: $0, range: nil) } + docComment = SymbolKit.SymbolGraph.LineList(lines) } // Create mixins for HTTP endpoint @@ -203,7 +409,7 @@ public struct SymbolGraphGenerator { baseURL: baseURL, path: path ) - mixins[SymbolKit.SymbolGraph.Symbol.HTTP.endpointMixinKey] = httpEndpoint + mixins[SymbolKit.SymbolGraph.Symbol.HTTP.Endpoint.mixinKey] = httpEndpoint } return SymbolKit.SymbolGraph.Symbol( @@ -212,7 +418,8 @@ public struct SymbolGraphGenerator { pathComponents: [path, method.rawValue], docComment: docComment, accessLevel: SymbolKit.SymbolGraph.Symbol.AccessControl(rawValue: "public"), - kind: .init(parsedIdentifier: .method, displayName: "Operation"), + // Use method kind for operations since httpRequest might not be available in this version + kind: .init(parsedIdentifier: .method, displayName: "HTTP \(method.rawValue.uppercased())"), mixins: mixins ) } @@ -293,24 +500,138 @@ public struct SymbolGraphGenerator { ) } + /// Improved method to create schema symbols for OpenAPI schemas private func createSchemaSymbol(name: String, schema: JSONSchema) -> SymbolKit.SymbolGraph.Symbol { let identifier = SymbolKit.SymbolGraph.Symbol.Identifier( precise: "schema:\(name)", interfaceLanguage: "openapi" ) + // Better names with improved navigator and subheading let names = SymbolKit.SymbolGraph.Symbol.Names( title: name, navigator: [.init(kind: .text, spelling: name, preciseIdentifier: nil)], - subHeading: nil, + subHeading: [.init(kind: .text, spelling: "Schema", preciseIdentifier: nil)], prose: nil ) - var docComment: SymbolKit.SymbolGraph.LineList? = nil + // Enhanced documentation that includes schema properties and constraints + var docLines: [String] = [] - if let description = schema.description { - let line = SymbolKit.SymbolGraph.LineList.Line(text: description, range: nil) - docComment = SymbolKit.SymbolGraph.LineList([line]) + // Add description if available + if let description = schema.description, !description.isEmpty { + docLines.append(description) + docLines.append("") // Add empty line after description + } + + // Add schema type information + var schemaType = "Object" + // Determine schema type and gather relevant information + switch schema { + case .object(let objSchema): + schemaType = "Object" + let properties = objSchema.properties + if !properties.isEmpty { + docLines.append("**Properties:**") + + let requiredProps: [String] = objSchema.required + for (propName, propSchema) in properties { + let required = requiredProps.contains(propName) ? "Required" : "Optional" + let propDesc = propSchema.description ?? "" + docLines.append("- `\(propName)` (\(required)): \(propDesc)") + } + } + + case .array(let arraySchema): + schemaType = "Array" + let itemType = "Array<\(getDisplayType(for: arraySchema.items))>" + docLines.append("**Item Type:** \(itemType)") + + case .string(let stringSchema): + schemaType = "String" + if let format = stringSchema.format { + docLines.append("**Format:** \(format.rawValue)") + } + if let pattern = stringSchema.pattern { + docLines.append("**Pattern:** `\(pattern)`") + } + if let minLength = stringSchema.minLength { + docLines.append("**Minimum Length:** \(minLength)") + } + if let maxLength = stringSchema.maxLength { + docLines.append("**Maximum Length:** \(maxLength)") + } + // Additional string constraints could be added here + + case .number(let numSchema): + schemaType = "Number" + if let minimum = numSchema.minimum { + let exclusive = numSchema.exclusiveMinimum ?? false + docLines.append("**Minimum:** \(minimum)\(exclusive ? " (exclusive)" : "")") + } + if let maximum = numSchema.maximum { + let exclusive = numSchema.exclusiveMaximum ?? false + docLines.append("**Maximum:** \(maximum)\(exclusive ? " (exclusive)" : "")") + } + if let multipleOf = numSchema.multipleOf { + docLines.append("**Multiple Of:** \(multipleOf)") + } + + case .integer(let intSchema): + schemaType = "Integer" + if let minimum = intSchema.minimum { + let exclusive = intSchema.exclusiveMinimum ?? false + docLines.append("**Minimum:** \(minimum)\(exclusive ? " (exclusive)" : "")") + } + if let maximum = intSchema.maximum { + let exclusive = intSchema.exclusiveMaximum ?? false + docLines.append("**Maximum:** \(maximum)\(exclusive ? " (exclusive)" : "")") + } + if let multipleOf = intSchema.multipleOf { + docLines.append("**Multiple Of:** \(multipleOf)") + } + + case .boolean(_): + schemaType = "Boolean" + + case .reference(let ref): + schemaType = "Reference" + docLines.append("**References:** `\(ref.ref)`") + + case .allOf(let schemas): + schemaType = "Composite (AllOf)" + docLines.append("**Combines all of the following schemas:**") + for (index, subSchema) in schemas.enumerated() { + let subType = self.getDisplayType(for: subSchema) + docLines.append("\(index + 1). \(subType)") + } + + case .anyOf(let schemas): + schemaType = "Composite (AnyOf)" + docLines.append("**Matches any of the following schemas:**") + for (index, subSchema) in schemas.enumerated() { + let subType = self.getDisplayType(for: subSchema) + docLines.append("\(index + 1). \(subType)") + } + + case .oneOf(let schemas): + schemaType = "Composite (OneOf)" + docLines.append("**Matches exactly one of the following schemas:**") + for (index, subSchema) in schemas.enumerated() { + let subType = self.getDisplayType(for: subSchema) + docLines.append("\(index + 1). \(subType)") + } + + case .not(let subSchema): + schemaType = "Not" + let negatedType = self.getDisplayType(for: subSchema) + docLines.append("**Must not match:** \(negatedType)") + } + + var docComment: SymbolKit.SymbolGraph.LineList? = nil + if !docLines.isEmpty { + let lines = docLines.map { SymbolKit.SymbolGraph.LineList.Line(text: $0, range: nil) } + docComment = SymbolKit.SymbolGraph.LineList(lines) } return SymbolKit.SymbolGraph.Symbol( @@ -319,11 +640,35 @@ public struct SymbolGraphGenerator { pathComponents: [name], docComment: docComment, accessLevel: SymbolKit.SymbolGraph.Symbol.AccessControl(rawValue: "public"), - kind: .init(parsedIdentifier: .struct, displayName: "Schema"), + // Use struct kind for all schemas for simplicity + kind: .init(parsedIdentifier: .struct, displayName: schemaType), mixins: [:] ) } + /// Get a display-friendly type name for a schema + private func getDisplayType(for schema: JSONSchema) -> String { + switch schema { + case .string(_): return "String" + case .number(_): return "Number" + case .integer(_): return "Integer" + case .boolean(_): return "Boolean" + case .array(let arraySchema): + return "Array<\(getDisplayType(for: arraySchema.items))>" + case .object(_): return "Object" + case .reference(let ref): + // Extract name from reference + if let refName = ref.ref.split(separator: "/").last { + return String(refName) + } + return "Reference" + case .allOf(_): return "AllOf Composite" + case .anyOf(_): return "AnyOf Composite" + case .oneOf(_): return "OneOf Composite" + case .not(let schema): return "Not<\(getDisplayType(for: schema))>" + } + } + private func createMetadata(from document: Document) -> SymbolKit.SymbolGraph.Metadata { return SymbolKit.SymbolGraph.Metadata( formatVersion: SymbolKit.SymbolGraph.SemanticVersion(major: 0, minor: 5, patch: 3), diff --git a/Sources/Integration/Converter.swift b/Sources/Integration/Converter.swift new file mode 100644 index 00000000..c012b43c --- /dev/null +++ b/Sources/Integration/Converter.swift @@ -0,0 +1,109 @@ +import Foundation +import OpenAPI +import SymbolKit +import OpenAPIKit + +/// Converts an OpenAPI document into a SymbolKit Symbol Graph. +/// +/// - Parameters: +/// - openAPIDocument: The parsed OpenAPI document. +/// - moduleName: The name to use for the documentation module. +/// - baseURL: An optional base URL to associate with the API endpoints. +/// - Returns: A SymbolKit SymbolGraph representing the OpenAPI document. +func convertOpenAPIToSymbolGraph( + openAPIDocument: OpenAPI.Document, + moduleName: String, + baseURL: URL? = nil +) -> SymbolGraph { + + // Create basic metadata and module + let metadata = SymbolGraph.Metadata( + formatVersion: .init(major: 1, minor: 0, patch: 0), + generator: "openapi-to-symbolgraph" + ) + + let module = SymbolGraph.Module( + name: moduleName, + platform: .init(architecture: nil, vendor: nil, operatingSystem: nil) + ) + + // Create simplified symbols for API info + var symbols: [SymbolGraph.Symbol] = [] + var relationships: [SymbolGraph.Relationship] = [] + + // Create module symbol + let moduleUSR = "oapi://\(moduleName)" + let moduleSymbol = createModuleSymbol(usr: moduleUSR, title: moduleName, description: openAPIDocument.info.description ?? "") + symbols.append(moduleSymbol) + + // Create basic path symbols - simplified approach + for (path, _) in openAPIDocument.paths { + let pathString = path.rawValue + let pathSymbol = createPathSymbol( + usr: "oapi://\(moduleName)/paths/\(pathString.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? pathString)", + path: pathString + ) + symbols.append(pathSymbol) + + // Add path-to-module relationship + relationships.append(SymbolGraph.Relationship( + source: pathSymbol.identifier.precise, + target: moduleUSR, + kind: .memberOf, + targetFallback: moduleName + )) + } + + return SymbolGraph( + metadata: metadata, + module: module, + symbols: symbols, + relationships: relationships + ) +} + +// MARK: - Helper Methods + +private func createModuleSymbol(usr: String, title: String, description: String) -> SymbolGraph.Symbol { + let docComment: SymbolGraph.LineList? + if !description.isEmpty { + let lines = description.split(separator: "\n").map { + SymbolGraph.LineList.Line(text: String($0), range: nil) + } + docComment = SymbolGraph.LineList(lines) + } else { + docComment = nil + } + + return SymbolGraph.Symbol( + identifier: .init(precise: usr, interfaceLanguage: "OpenAPI"), + names: SymbolGraph.Symbol.Names( + title: title, + navigator: nil, + subHeading: nil, + prose: nil + ), + pathComponents: [title], + docComment: docComment, + accessLevel: SymbolGraph.Symbol.AccessControl(rawValue: "public"), + kind: .init(parsedIdentifier: .module, displayName: "API"), + mixins: [:] + ) +} + +private func createPathSymbol(usr: String, path: String) -> SymbolGraph.Symbol { + return SymbolGraph.Symbol( + identifier: .init(precise: usr, interfaceLanguage: "OpenAPI"), + names: SymbolGraph.Symbol.Names( + title: path, + navigator: nil, + subHeading: nil, + prose: nil + ), + pathComponents: [path], + docComment: nil, + accessLevel: SymbolGraph.Symbol.AccessControl(rawValue: "public"), + kind: .init(parsedIdentifier: .protocol, displayName: "Path"), + mixins: [:] + ) +} diff --git a/Sources/Integration/OpenAPIDocCConverter.swift b/Sources/Integration/OpenAPIDocCConverter.swift index 74a2ceb6..b4bd95f9 100644 --- a/Sources/Integration/OpenAPIDocCConverter.swift +++ b/Sources/Integration/OpenAPIDocCConverter.swift @@ -20,7 +20,13 @@ public struct OpenAPIDocCConverter { /// - Parameter document: The OpenAPI document to convert /// - Returns: The DocC symbol graph public func convert(_ document: Document) -> SymbolKit.SymbolGraph { - let generator = SymbolGraphGenerator(moduleName: moduleName, baseURL: baseURL) + let actualModuleName = moduleName ?? document.info.title + + // Use DocC.SymbolGraphGenerator which is already fixed and working + var generator = DocC.SymbolGraphGenerator( + moduleName: actualModuleName, + baseURL: baseURL + ) return generator.generate(from: document) } } diff --git a/docc-sample b/docc-sample new file mode 160000 index 00000000..4d53b74c --- /dev/null +++ b/docc-sample @@ -0,0 +1 @@ +Subproject commit 4d53b74c5cf5cdd45526a07d89c2e017b8989b9e diff --git a/docs/.nojekyll b/docs/.nojekyll index 0519ecba..e69de29b 100644 --- a/docs/.nojekyll +++ b/docs/.nojekyll @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/docs/data/documentation/registry-api/authentication.json b/docs/data/documentation/registry-api/authentication.json new file mode 100644 index 00000000..42c5d6d2 --- /dev/null +++ b/docs/data/documentation/registry-api/authentication.json @@ -0,0 +1 @@ +{"schemaVersion":{"major":0,"patch":0,"minor":3},"seeAlsoSections":[{"anchor":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"generated":true,"title":"Guides"}],"kind":"article","primaryContentSections":[{"kind":"content","content":[{"anchor":"Overview","text":"Overview","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"The Swift Package Registry API uses token-based authentication to secure access to private packages and privileged operations like publishing. This guide explains how to authenticate your requests."}]},{"anchor":"Obtaining-an-Authentication-Token","text":"Obtaining an Authentication Token","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"text":"To get an authentication token, you’ll typically use the login endpoint:","type":"text"}]},{"syntax":"swift","code":["\/\/ Create login request","let loginURL = URL(string: \"https:\/\/registry.example.com\/login\")!","var request = URLRequest(url: loginURL)","request.httpMethod = \"POST\"","request.setValue(\"application\/json\", forHTTPHeaderField: \"Content-Type\")","","\/\/ Set credentials - implementation depends on registry provider","let credentials = [\"username\": \"your-username\", \"password\": \"your-password\"]","request.httpBody = try JSONEncoder().encode(credentials)","","\/\/ Send request","let (data, response) = try await URLSession.shared.data(for: request)","","\/\/ Parse token from response","let tokenResponse = try JSONDecoder().decode(TokenResponse.self, from: data)","let authToken = tokenResponse.token"],"type":"codeListing"},{"anchor":"Using-Authentication-Tokens","text":"Using Authentication Tokens","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Once you have a token, include it in your request headers:"}]},{"syntax":"swift","code":["\/\/ Create authenticated request","let packageURL = URL(string: \"https:\/\/registry.example.com\/mona\/LinkedList\/1.1.1\")!","var request = URLRequest(url: packageURL)","","\/\/ Add the authorization header","request.setValue(\"Bearer \\(authToken)\", forHTTPHeaderField: \"Authorization\")","","\/\/ Send request","let (data, response) = try await URLSession.shared.data(for: request)"],"type":"codeListing"},{"anchor":"Token-Management","text":"Token Management","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Authentication tokens typically have an expiration period. You should:"}]},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"text":"Store tokens securely (e.g., in the keychain on Apple platforms)","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"text","text":"Handle token refresh when tokens expire"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Never expose tokens in client-side code for public applications"}]}]}],"type":"orderedList"},{"anchor":"Authentication-for-Different-Operations","text":"Authentication for Different Operations","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"text":"Different operations may require different scopes or permissions:","type":"text"}]},{"rows":[[[{"type":"paragraph","inlineContent":[{"text":"Operation","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"Required Permissions","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"Read public packages","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"None (anonymous access)"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Read private packages"}]}],[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"read"},{"type":"text","text":" scope"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Publish packages"}]}],[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"write"},{"type":"text","text":" scope"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"Manage organization","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"code":"admin","type":"codeVoice"},{"text":" scope","type":"text"}]}]]],"type":"table","header":"row"},{"type":"heading","text":"Next Steps","level":2,"anchor":"Next-Steps"},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"text":"Learn how to ","type":"text"},{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","isActive":true,"type":"reference"},{"text":" packages to the registry","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Review specific endpoint documentation for authorization requirements"}]}]}]}]}],"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"metadata":{"title":"Authentication","role":"article","modules":[{"name":"Registry API"}],"roleHeading":"Article"},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication"},"abstract":[{"text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing.","type":"text"}],"references":{"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/errorcodes.json b/docs/data/documentation/registry-api/errorcodes.json new file mode 100644 index 00000000..fac91e0a --- /dev/null +++ b/docs/data/documentation/registry-api/errorcodes.json @@ -0,0 +1 @@ +{"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes"},"kind":"article","metadata":{"title":"Error Codes","role":"article","modules":[{"name":"Registry API"}],"roleHeading":"Article"},"primaryContentSections":[{"content":[{"anchor":"Overview","text":"Overview","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"text":"The Swift Package Registry API uses standard HTTP status codes combined with detailed error responses to provide clear information about what went wrong. All error responses follow the RFC 7807 Problem Details format, allowing both machines and humans to understand the nature of errors.","type":"text"}]},{"anchor":"Problem-Details-Response-Format","text":"Problem Details Response Format","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"text":"When an error occurs, the API returns a problem details object with the following structure:","type":"text"}]},{"type":"codeListing","syntax":"json","code":["{"," \"type\": \"https:\/\/registry.example.com\/docs\/errors\/invalid-version\","," \"title\": \"Invalid Version Format\","," \"status\": 400,"," \"detail\": \"The version '1.x' does not conform to semantic versioning requirements\","," \"instance\": \"urn:uuid:6493675d-9af4-4f9d-b8c3-90c5e33f3db1\"","}"]},{"type":"paragraph","inlineContent":[{"type":"text","text":"The object contains these fields:"}]},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"type"},{"text":": A URI reference that identifies the problem type","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"title","type":"codeVoice"},{"type":"text","text":": A short, human-readable summary of the problem"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"status","type":"codeVoice"},{"text":": The HTTP status code","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"detail","type":"codeVoice"},{"text":": A human-readable explanation specific to this occurrence of the problem","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"instance"},{"text":": A URI reference that identifies the specific occurrence of the problem","type":"text"}],"type":"paragraph"}]}]},{"anchor":"Common-Error-Types","text":"Common Error Types","type":"heading","level":2},{"anchor":"Authentication-Errors-401-403","text":"Authentication Errors (401, 403)","type":"heading","level":3},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"text":"Status","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Type"}]}],[{"type":"paragraph","inlineContent":[{"text":"Description","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"401"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"unauthorized"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"The request lacks valid authentication credentials"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"403","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"forbidden"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"The authenticated user lacks permission for the requested operation"}]}]]],"header":"row"},{"type":"codeListing","syntax":"swift","code":["\/\/ Example: Handling an authentication error","do {"," let (data, response) = try await session.data(for: request)"," guard let httpResponse = response as? HTTPURLResponse else { return }"," "," if httpResponse.statusCode == 401 {"," \/\/ Handle unauthorized error - request new credentials"," refreshCredentials()"," } else if httpResponse.statusCode == 403 {"," \/\/ Handle forbidden error - inform user they lack permission"," showPermissionError()"," }","} catch {"," \/\/ Handle network errors","}"]},{"anchor":"Resource-Errors-404-410","text":"Resource Errors (404, 410)","type":"heading","level":3},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"text":"Status","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Type"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Description"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"404","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"not-found"}]}],[{"type":"paragraph","inlineContent":[{"text":"The requested resource does not exist","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"410"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"gone"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"The resource previously existed but is no longer available"}]}]]],"header":"row"},{"anchor":"Request-Validation-Errors-400-422","text":"Request Validation Errors (400, 422)","type":"heading","level":3},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Status"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Type"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Description"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"400","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"bad-request","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"The request could not be understood or was missing required parameters"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"422"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"validation-failed"}]}],[{"type":"paragraph","inlineContent":[{"text":"The request was well-formed but contained semantic errors","type":"text"}]}]]],"header":"row"},{"anchor":"Rate-Limiting-Errors-429","text":"Rate Limiting Errors (429)","type":"heading","level":3},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Status"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Type"}]}],[{"type":"paragraph","inlineContent":[{"text":"Description","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"429","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"too-many-requests"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"The client has sent too many requests in a given time period"}]}]]],"header":"row"},{"type":"paragraph","inlineContent":[{"text":"Rate limiting responses include additional headers:","type":"text"}]},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"code":"RateLimit-Limit","type":"codeVoice"},{"text":": The maximum number of requests allowed in the current time window","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"RateLimit-Remaining"},{"type":"text","text":": The number of requests remaining in the current time window"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"RateLimit-Reset"},{"type":"text","text":": The time when the current rate limit window resets (in UTC epoch seconds)"}]}]}]},{"anchor":"Server-Errors-500-503","text":"Server Errors (500, 503)","type":"heading","level":3},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"text":"Status","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"Type","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Description"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"500"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"server-error"}]}],[{"type":"paragraph","inlineContent":[{"text":"An unexpected error occurred on the server","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"503"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"service-unavailable"}]}],[{"type":"paragraph","inlineContent":[{"text":"The service is temporarily unavailable","type":"text"}]}]]],"header":"row"},{"anchor":"Best-Practices-for-Error-Handling","text":"Best Practices for Error Handling","type":"heading","level":2},{"type":"orderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Always check status codes"}],"type":"strong"},{"text":": Validate HTTP status codes before processing responses","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Parse problem details"}],"type":"strong"},{"text":": Extract the detailed error information from the response body","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Implement exponential backoff"}]},{"type":"text","text":": For rate limiting and server errors, use increasing delays between retries"}]}]},{"content":[{"inlineContent":[{"inlineContent":[{"text":"Present meaningful messages","type":"text"}],"type":"strong"},{"text":": Translate error responses into user-friendly messages","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Log rich error data"}],"type":"strong"},{"text":": Include the error ","type":"text"},{"code":"type","type":"codeVoice"},{"text":" and ","type":"text"},{"code":"instance","type":"codeVoice"},{"text":" in logs for easier troubleshooting","type":"text"}]}]}]},{"code":["\/\/ Example: Comprehensive error handling with retry logic","func fetchPackage(scope: String, name: String, version: String) async throws -> Data {"," var retryCount = 0"," let maxRetries = 3"," "," while true {"," do {"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\/\\(version).zip\")!"," let (data, response) = try await URLSession.shared.data(from: url)"," "," guard let httpResponse = response as? HTTPURLResponse else {"," throw RegistryError.invalidResponse"," }"," "," switch httpResponse.statusCode {"," case 200..<300:"," return data"," case 429:"," if retryCount >= maxRetries {"," throw RegistryError.rateLimitExceeded"," }"," "," \/\/ Parse retry-after header or use exponential backoff"," let retryAfter = httpResponse.value(forHTTPHeaderField: \"Retry-After\")"," .flatMap(Int.init) ?? Int(pow(2.0, Double(retryCount + 1)))"," "," \/\/ Wait before retrying"," try await Task.sleep(nanoseconds: UInt64(retryAfter * 1_000_000_000))"," retryCount += 1"," continue"," "," case 400..<500:"," \/\/ Parse problem details"," let problem = try JSONDecoder().decode(ProblemDetails.self, from: data)"," throw RegistryError.clientError(problem)"," "," case 500..<600:"," if retryCount >= maxRetries {"," throw RegistryError.serverError"," }"," "," \/\/ Use exponential backoff for server errors"," try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(retryCount + 1)) * 1_000_000_000))"," retryCount += 1"," continue"," "," default:"," throw RegistryError.unknownError"," }"," } catch {"," if retryCount >= maxRetries {"," throw error"," }"," "," \/\/ Network error - retry with backoff"," try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(retryCount + 1)) * 1_000_000_000))"," retryCount += 1"," }"," }","}"],"syntax":"swift","type":"codeListing"}],"kind":"content"}],"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"schemaVersion":{"major":0,"patch":0,"minor":3},"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"seeAlsoSections":[{"title":"Related Documentation","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails"],"anchor":"Related-Documentation"},{"title":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"anchor":"Guides","generated":true}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/gettingstarted.json b/docs/data/documentation/registry-api/gettingstarted.json new file mode 100644 index 00000000..91845780 --- /dev/null +++ b/docs/data/documentation/registry-api/gettingstarted.json @@ -0,0 +1 @@ +{"schemaVersion":{"minor":3,"patch":0,"major":0},"metadata":{"roleHeading":"Article","modules":[{"name":"Registry API"}],"title":"Getting Started with Swift Package Registry","role":"article"},"abstract":[{"type":"text","text":"Learn how to use the Swift Package Registry API to discover and retrieve packages."}],"sections":[],"primaryContentSections":[{"kind":"content","content":[{"anchor":"Overview","level":2,"text":"Overview","type":"heading"},{"inlineContent":[{"type":"text","text":"The Swift Package Registry API provides a standardized way to interact with package repositories. This guide will help you understand the basic operations and how to make your first API calls."}],"type":"paragraph"},{"anchor":"Discovering-Packages","level":2,"text":"Discovering Packages","type":"heading"},{"inlineContent":[{"type":"text","text":"To find a package in the registry, you can use the package identifier lookup endpoint:"}],"type":"paragraph"},{"syntax":"swift","code":["\/\/ Find all packages matching a partial name","let url = URL(string: \"https:\/\/registry.example.com\/identifiers?query=networking\")!","let (data, _) = try await URLSession.shared.data(from: url)","\/\/ Parse the JSON response","let identifiers = try JSONDecoder().decode([Identifier].self, from: data)"],"type":"codeListing"},{"anchor":"Retrieving-Package-Information","level":2,"text":"Retrieving Package Information","type":"heading"},{"inlineContent":[{"type":"text","text":"Once you have a package identifier, you can retrieve detailed information:"}],"type":"paragraph"},{"syntax":"swift","code":["\/\/ Get information about a specific package","let packageScope = \"mona\"","let packageName = \"LinkedList\"","let url = URL(string: \"https:\/\/registry.example.com\/\\(packageScope)\/\\(packageName)\")!","let (data, _) = try await URLSession.shared.data(from: url)","\/\/ Parse the JSON response","let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)"],"type":"codeListing"},{"anchor":"Downloading-a-Package-Version","level":2,"text":"Downloading a Package Version","type":"heading"},{"inlineContent":[{"text":"To download a specific version of a package:","type":"text"}],"type":"paragraph"},{"syntax":"swift","code":["\/\/ Download a specific version","let packageScope = \"mona\"","let packageName = \"LinkedList\"","let version = \"1.1.1\"","let url = URL(string: \"https:\/\/registry.example.com\/\\(packageScope)\/\\(packageName)\/\\(version).zip\")!","let (zipData, _) = try await URLSession.shared.data(from: url)","\/\/ Save or process the zip file","try zipData.write(to: zipFileURL)"],"type":"codeListing"},{"type":"heading","level":2,"anchor":"Next-Steps","text":"Next Steps"},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"text":"Learn about ","type":"text"},{"isActive":true,"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","type":"reference"},{"text":" to access private packages","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"text":"Explore how to ","type":"text"},{"isActive":true,"type":"reference","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing"},{"text":" your own packages to the registry","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"text":"Review the full API reference for detailed endpoint information","type":"text"}]}]}]}]}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"kind":"article","identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/GettingStarted","interfaceLanguage":"openapi"},"references":{"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/performance.json b/docs/data/documentation/registry-api/performance.json new file mode 100644 index 00000000..fd9d37df --- /dev/null +++ b/docs/data/documentation/registry-api/performance.json @@ -0,0 +1 @@ +{"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","interfaceLanguage":"openapi"},"kind":"article","schemaVersion":{"major":0,"minor":3,"patch":0},"abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"primaryContentSections":[{"content":[{"type":"heading","text":"Overview","anchor":"Overview","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Optimizing your interactions with the Swift Package Registry API can significantly improve your application’s performance and user experience. This guide covers best practices for efficient API usage, including caching strategies, concurrent requests, and optimizing data transfers."}]},{"type":"paragraph","inlineContent":[]},{"type":"heading","text":"Caching Strategies","anchor":"Caching-Strategies","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Implementing effective caching is one of the most important ways to improve performance when working with the Registry API."}]},{"type":"heading","text":"Memory Caching","anchor":"Memory-Caching","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"For frequently accessed data that doesn’t change often, implement in-memory caching:"}]},{"type":"codeListing","code":["class RegistryAPIClient {"," \/\/ Simple memory cache with expiration support"," private class Cache {"," private struct CacheEntry {"," let value: V"," let expirationDate: Date"," }"," "," private var storage = [K: CacheEntry]()"," private let lock = NSLock()"," "," func set(_ value: V, forKey key: K, expirationInterval: TimeInterval) {"," lock.lock()"," defer { lock.unlock() }"," "," let expirationDate = Date().addingTimeInterval(expirationInterval)"," storage[key] = CacheEntry(value: value, expirationDate: expirationDate)"," }"," "," func get(forKey key: K) -> V? {"," lock.lock()"," defer { lock.unlock() }"," "," guard let entry = storage[key], entry.expirationDate > Date() else {"," \/\/ Remove expired entry if it exists"," storage.removeValue(forKey: key)"," return nil"," }"," "," return entry.value"," }"," "," func removeAll() {"," lock.lock()"," defer { lock.unlock() }"," storage.removeAll()"," }"," }"," "," \/\/ Cache for package metadata (larger TTL since metadata changes less frequently)"," private let metadataCache = Cache()"," "," \/\/ Cache for package identifiers (shorter TTL since search results may change)"," private let identifierCache = Cache()"," "," func fetchPackageMetadata(scope: String, name: String) async throws -> PackageMetadata {"," let cacheKey = \"\\(scope)\/\\(name)\""," "," \/\/ Check cache first"," if let cachedMetadata = metadataCache.get(forKey: cacheKey) {"," return cachedMetadata"," }"," "," \/\/ Fetch from network"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\")!"," let (data, _) = try await URLSession.shared.data(from: url)"," let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)"," "," \/\/ Cache result (30 minute TTL)"," metadataCache.set(metadata, forKey: cacheKey, expirationInterval: 30 * 60)"," "," return metadata"," }","}"],"syntax":"swift"},{"type":"heading","text":"Persistent Caching","anchor":"Persistent-Caching","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"For data that should persist between app launches:"}]},{"type":"codeListing","code":["class PersistentCache {"," private let fileManager = FileManager.default"," private let cacheDirectory: URL"," "," init() throws {"," let cacheURL = try fileManager.url("," for: .cachesDirectory, "," in: .userDomainMask, "," appropriateFor: nil, "," create: true"," )"," cacheDirectory = cacheURL.appendingPathComponent(\"RegistryCache\", isDirectory: true)"," "," if !fileManager.fileExists(atPath: cacheDirectory.path) {"," try fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true)"," }"," }"," "," func cacheData(_ data: Data, forKey key: String, expirationInterval: TimeInterval) throws {"," let fileURL = cacheDirectory.appendingPathComponent(key.md5Hash)"," try data.write(to: fileURL)"," "," \/\/ Store metadata including expiration"," let metadata: [String: Any] = ["," \"key\": key,"," \"expiration\": Date().addingTimeInterval(expirationInterval).timeIntervalSince1970"," ]"," let metadataURL = fileURL.appendingPathExtension(\"metadata\")"," let metadataData = try JSONSerialization.data(withJSONObject: metadata)"," try metadataData.write(to: metadataURL)"," }"," "," func getData(forKey key: String) throws -> Data? {"," let fileURL = cacheDirectory.appendingPathComponent(key.md5Hash)"," let metadataURL = fileURL.appendingPathExtension(\"metadata\")"," "," \/\/ Check if file exists"," guard fileManager.fileExists(atPath: fileURL.path),"," fileManager.fileExists(atPath: metadataURL.path) else {"," return nil"," }"," "," \/\/ Check expiration"," let metadataData = try Data(contentsOf: metadataURL)"," let metadata = try JSONSerialization.jsonObject(with: metadataData) as? [String: Any]"," "," if let expirationTimestamp = metadata?[\"expiration\"] as? TimeInterval,"," Date(timeIntervalSince1970: expirationTimestamp) > Date() {"," \/\/ Not expired, return data"," return try Data(contentsOf: fileURL)"," } else {"," \/\/ Expired, clean up files"," try? fileManager.removeItem(at: fileURL)"," try? fileManager.removeItem(at: metadataURL)"," return nil"," }"," }","}"],"syntax":"swift"},{"type":"heading","text":"Conditional Requests","anchor":"Conditional-Requests","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"Use HTTP conditional requests with ETag or Last-Modified headers to avoid downloading unchanged data:"}]},{"type":"codeListing","code":["class ConditionalRequestClient {"," private var etagStorage: [String: String] = [:]"," "," func fetchWithConditionalRequest(url: URL) async throws -> Data {"," var request = URLRequest(url: url)"," "," \/\/ Add conditional header if we have an ETag"," let resourceKey = url.absoluteString"," if let etag = etagStorage[resourceKey] {"," request.addValue(etag, forHTTPHeaderField: \"If-None-Match\")"," }"," "," let (data, response) = try await URLSession.shared.data(for: request)"," guard let httpResponse = response as? HTTPURLResponse else {"," throw APIError.invalidResponse"," }"," "," \/\/ Store ETag if present"," if let newETag = httpResponse.value(forHTTPHeaderField: \"ETag\") {"," etagStorage[resourceKey] = newETag"," }"," "," if httpResponse.statusCode == 304 {"," \/\/ Resource not modified, return cached data"," guard let cachedData = try PersistentCache().getData(forKey: resourceKey) else {"," throw APIError.cacheInconsistency"," }"," return cachedData"," } else if (200..<300).contains(httpResponse.statusCode) {"," \/\/ New or modified data"," try PersistentCache().cacheData(data, forKey: resourceKey, expirationInterval: 3600)"," return data"," } else {"," throw APIError.httpError(httpResponse.statusCode)"," }"," }","}"],"syntax":"swift"},{"type":"heading","text":"Optimizing Data Transfers","anchor":"Optimizing-Data-Transfers","level":2},{"type":"heading","text":"Compression","anchor":"Compression","level":3},{"type":"paragraph","inlineContent":[{"text":"The Registry API supports gzip compression. Enable it in your requests:","type":"text"}]},{"type":"codeListing","code":["var request = URLRequest(url: url)","request.addValue(\"gzip, deflate\", forHTTPHeaderField: \"Accept-Encoding\")"],"syntax":"swift"},{"type":"heading","text":"Request Only What You Need","anchor":"Request-Only-What-You-Need","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"Use query parameters to limit the data you retrieve:"}]},{"type":"codeListing","code":["\/\/ Example: Limiting the number of results","func searchPackages(query: String, limit: Int = 20) async throws -> [Identifier] {"," let urlString = \"https:\/\/registry.example.com\/identifiers?query=\\(query)&limit=\\(limit)\""," guard let url = URL(string: urlString) else {"," throw URLError(.badURL)"," }"," "," let (data, _) = try await URLSession.shared.data(from: url)"," return try JSONDecoder().decode([Identifier].self, from: data)","}"],"syntax":"swift"},{"type":"heading","text":"Avoiding Redundant Requests","anchor":"Avoiding-Redundant-Requests","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"Track in-flight requests to avoid duplicate network calls:"}]},{"type":"codeListing","code":["class APIRequestCoordinator {"," private var inFlightRequests = [URL: Task]()"," private let lock = NSLock()"," "," func performRequest(for url: URL) async throws -> Data {"," lock.lock()"," "," \/\/ Check if there's already an in-flight request for this URL"," if let existingTask = inFlightRequests[url] {"," lock.unlock()"," return try await existingTask.value"," }"," "," \/\/ Create a new task for this request"," let task = Task {"," defer {"," lock.lock()"," inFlightRequests[url] = nil"," lock.unlock()"," }"," "," let (data, _) = try await URLSession.shared.data(from: url)"," return data"," }"," "," \/\/ Store the task"," inFlightRequests[url] = task"," lock.unlock()"," "," return try await task.value"," }","}"],"syntax":"swift"},{"type":"heading","text":"Concurrent Operations","anchor":"Concurrent-Operations","level":2},{"type":"heading","text":"Parallel Downloads","anchor":"Parallel-Downloads","level":3},{"type":"paragraph","inlineContent":[{"text":"Download multiple packages in parallel for faster bulk operations:","type":"text"}]},{"type":"codeListing","code":["func downloadMultiplePackages(packages: [(scope: String, name: String, version: String)]) async throws -> [String: Data] {"," \/\/ Create a task for each package"," let tasks = packages.map { package in"," Task {"," let (scope, name, version) = package"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\/\\(version).zip\")!"," let (data, _) = try await URLSession.shared.data(from: url)"," return (key: \"\\(scope)\/\\(name)\/\\(version)\", data: data)"," }"," }"," "," \/\/ Wait for all tasks to complete"," var results = [String: Data]()"," for task in tasks {"," do {"," let (key, data) = try await task.value"," results[key] = data"," } catch {"," \/\/ Handle individual download failures"," print(\"Failed to download package: \\(error.localizedDescription)\")"," }"," }"," "," return results","}"],"syntax":"swift"},{"type":"heading","text":"Task Prioritization","anchor":"Task-Prioritization","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"Use task priorities for critical vs. background operations:"}]},{"type":"codeListing","code":["\/\/ High-priority task (e.g., user-initiated download)","let highPriorityTask = Task(priority: .userInitiated) {"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\/\\(version).zip\")!"," return try await URLSession.shared.data(from: url)","}","","\/\/ Background task (e.g., prefetching)","let backgroundTask = Task(priority: .background) {"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\")!"," return try await URLSession.shared.data(from: url)","}"],"syntax":"swift"},{"type":"heading","text":"Network Efficiency","anchor":"Network-Efficiency","level":2},{"type":"heading","text":"Connection Pooling","anchor":"Connection-Pooling","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"Configure your URLSession for connection reuse:"}]},{"type":"codeListing","code":["let configuration = URLSessionConfiguration.default","configuration.httpMaximumConnectionsPerHost = 6 \/\/ Default is 6","configuration.timeoutIntervalForRequest = 30.0 \/\/ 30 seconds","configuration.timeoutIntervalForResource = 60.0 \/\/ 60 seconds","","let session = URLSession(configuration: configuration)"],"syntax":"swift"},{"type":"heading","text":"Batch Operations","anchor":"Batch-Operations","level":3},{"type":"paragraph","inlineContent":[{"type":"text","text":"When possible, use batch operations to reduce round trips:"}]},{"type":"codeListing","code":["\/\/ Instead of multiple separate requests","func batchFetchIdentifiers(queries: [String]) async throws -> [String: [Identifier]] {"," let queryString = queries.joined(separator: \",\")"," let url = URL(string: \"https:\/\/registry.example.com\/identifiers?queries=\\(queryString)\")!"," "," let (data, _) = try await URLSession.shared.data(from: url)"," return try JSONDecoder().decode([String: [Identifier]].self, from: data)","}"],"syntax":"swift"},{"type":"heading","text":"Prefetching and Predictive Loading","anchor":"Prefetching-and-Predictive-Loading","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Implement predictive loading for a smoother user experience:"}]},{"type":"codeListing","code":["class PredictiveLoader {"," private let prefetchQueue = OperationQueue()"," private var prefetchedData = [URL: Data]()"," "," init() {"," prefetchQueue.maxConcurrentOperationCount = 2"," prefetchQueue.qualityOfService = .utility"," }"," "," func prefetchRelatedPackages(for package: PackageMetadata) {"," guard let dependencies = package.dependencies else { return }"," "," for dependency in dependencies {"," let dependencyURL = URL(string: \"https:\/\/registry.example.com\/\\(dependency.scope)\/\\(dependency.name)\")!"," "," Task(priority: .background) {"," do {"," let (data, _) = try await URLSession.shared.data(from: dependencyURL)"," prefetchedData[dependencyURL] = data"," } catch {"," \/\/ Silently fail for prefetching"," print(\"Failed to prefetch \\(dependencyURL): \\(error.localizedDescription)\")"," }"," }"," }"," }"," "," func getPrefetchedData(for url: URL) -> Data? {"," return prefetchedData[url]"," }","}"],"syntax":"swift"},{"type":"heading","text":"Monitoring and Analytics","anchor":"Monitoring-and-Analytics","level":2},{"type":"paragraph","inlineContent":[{"text":"Implement performance monitoring to identify bottlenecks:","type":"text"}]},{"type":"codeListing","code":["class PerformanceMonitor {"," private var requestTimings = [String: [TimeInterval]]()"," private let lock = NSLock()"," "," func recordRequestStart(endpoint: String) -> CFAbsoluteTime {"," return CFAbsoluteTimeGetCurrent()"," }"," "," func recordRequestEnd(endpoint: String, startTime: CFAbsoluteTime) {"," let duration = CFAbsoluteTimeGetCurrent() - startTime"," "," lock.lock()"," defer { lock.unlock() }"," "," if requestTimings[endpoint] == nil {"," requestTimings[endpoint] = [duration]"," } else {"," requestTimings[endpoint]?.append(duration)"," }"," "," \/\/ Log slow requests"," if duration > 1.0 {"," print(\"⚠ī¸ Slow request to \\(endpoint): \\(String(format: \"%.2f\", duration))s\")"," }"," }"," "," func getAverageResponseTime(for endpoint: String) -> TimeInterval? {"," lock.lock()"," defer { lock.unlock() }"," "," guard let timings = requestTimings[endpoint], !timings.isEmpty else {"," return nil"," }"," "," return timings.reduce(0, +) \/ Double(timings.count)"," }"," "," func generatePerformanceReport() -> [String: Any] {"," lock.lock()"," defer { lock.unlock() }"," "," var report = [String: Any]()"," "," for (endpoint, timings) in requestTimings {"," guard !timings.isEmpty else { continue }"," "," let avgTime = timings.reduce(0, +) \/ Double(timings.count)"," let maxTime = timings.max() ?? 0"," let minTime = timings.min() ?? 0"," "," report[endpoint] = ["," \"avg\": avgTime,"," \"min\": minTime,"," \"max\": maxTime,"," \"count\": timings.count"," ]"," }"," "," return report"," }","}"],"syntax":"swift"},{"type":"heading","text":"Best Practices Summary","anchor":"Best-Practices-Summary","level":2},{"type":"orderedList","items":[{"content":[{"inlineContent":[{"type":"strong","inlineContent":[{"text":"Implement comprehensive caching","type":"text"}]},{"text":":","type":"text"}],"type":"paragraph"},{"items":[{"content":[{"inlineContent":[{"type":"text","text":"Use memory caching for frequently accessed data"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Add persistent caching for larger or less frequently changing data"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Implement conditional requests with ETags"}],"type":"paragraph"}]}],"type":"unorderedList"}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"text":"Optimize network usage","type":"text"}],"type":"strong"},{"text":":","type":"text"}]},{"items":[{"content":[{"inlineContent":[{"text":"Enable compression in requests","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Limit response size with query parameters"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Deduplicate in-flight requests"}]}]}],"type":"unorderedList"}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Use concurrency effectively"}],"type":"strong"},{"type":"text","text":":"}]},{"items":[{"content":[{"inlineContent":[{"text":"Download resources in parallel","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Prioritize user-initiated tasks"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Implement connection pooling"}]}]}],"type":"unorderedList"}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Implement predictive loading"}],"type":"strong"},{"text":":","type":"text"}]},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Prefetch likely-to-be-needed resources"}]}]},{"content":[{"inlineContent":[{"type":"text","text":"Load related packages in the background"}],"type":"paragraph"}]}]}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"type":"text","text":"Monitor performance"}],"type":"strong"},{"type":"text","text":":"}]},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"text":"Track request timings","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"text":"Identify slow operations","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"text","text":"Generate reports for optimization opportunities"}],"type":"paragraph"}]}]}]}]}],"kind":"content"}],"seeAlsoSections":[{"anchor":"Related-Documentation","title":"Related Documentation","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes"]},{"generated":true,"title":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security"],"anchor":"Guides"}],"sections":[],"metadata":{"roleHeading":"Article","role":"article","title":"Performance Optimization","modules":[{"name":"Registry API"}]},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"},"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/publishing.json b/docs/data/documentation/registry-api/publishing.json new file mode 100644 index 00000000..b45229b3 --- /dev/null +++ b/docs/data/documentation/registry-api/publishing.json @@ -0,0 +1 @@ +{"primaryContentSections":[{"kind":"content","content":[{"level":2,"text":"Overview","anchor":"Overview","type":"heading"},{"inlineContent":[{"type":"text","text":"Publishing your Swift package to a registry makes it easily accessible to others and enables versioning and dependency management. This guide walks you through the process of preparing and publishing a package."}],"type":"paragraph"},{"level":2,"text":"Preparing Your Package","anchor":"Preparing-Your-Package","type":"heading"},{"inlineContent":[{"text":"Before publishing, ensure your package is properly configured:","type":"text"}],"type":"paragraph"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Verify your Package.swift file has correct metadata:"}]},{"syntax":"swift","type":"codeListing","code":["\/\/ swift-tools-version: 5.7","import PackageDescription","","let package = Package("," name: \"MyLibrary\","," platforms: [.macOS(.v12), .iOS(.v15)],"," products: ["," .library(name: \"MyLibrary\", targets: [\"MyLibrary\"]),"," ],"," dependencies: [],"," targets: ["," .target(name: \"MyLibrary\"),"," .testTarget(name: \"MyLibraryTests\", dependencies: [\"MyLibrary\"]),"," ]",")"]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Make sure your version tags follow "},{"type":"reference","identifier":"https:\/\/semver.org\/","isActive":true},{"type":"text","text":" (e.g., "},{"type":"codeVoice","code":"1.0.0"},{"type":"text","text":", "},{"type":"codeVoice","code":"1.2.3"},{"type":"text","text":")"}]}]},{"content":[{"inlineContent":[{"type":"text","text":"Include a LICENSE file and README.md with clear documentation"}],"type":"paragraph"}]}],"type":"orderedList"},{"level":2,"text":"Publishing a New Version","anchor":"Publishing-a-New-Version","type":"heading"},{"inlineContent":[{"type":"text","text":"To publish a new version of your package:"}],"type":"paragraph"},{"syntax":"swift","code":["\/\/ Create a zip archive of your package","let packageData = createPackageZipArchive() \/\/ Implementation depends on your tooling","","\/\/ Set the authentication token","let authToken = \"your-auth-token\" \/\/ See Authentication guide","let packageScope = \"mona\"","let packageName = \"MyLibrary\"","let version = \"1.0.0\"","","\/\/ Create publish URL","let publishURL = URL(string: \"https:\/\/registry.example.com\/\\(packageScope)\/\\(packageName)\/\\(version)\")!","var request = URLRequest(url: publishURL)","request.httpMethod = \"PUT\"","request.setValue(\"application\/octet-stream\", forHTTPHeaderField: \"Content-Type\")","request.setValue(\"Bearer \\(authToken)\", forHTTPHeaderField: \"Authorization\")","request.setValue(\"sha256=\\(calculateSHA256(packageData))\", forHTTPHeaderField: \"X-Swift-Package-Signature\")","","\/\/ Set the package data","request.httpBody = packageData","","\/\/ Send request","let (responseData, response) = try await URLSession.shared.data(for: request)","","\/\/ Check response status","if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 201 {"," print(\"Package version published successfully!\")","}"],"type":"codeListing"},{"anchor":"Handling-Responses","level":2,"text":"Handling Responses","type":"heading"},{"inlineContent":[{"type":"text","text":"The registry returns specific status codes:"}],"type":"paragraph"},{"rows":[[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Status Code"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Meaning"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"201","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Created - version published successfully"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"202"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Accepted - version queued for processing"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"409","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"Conflict - version already exists","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"422","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"Unprocessable - invalid package","type":"text"}]}]]],"header":"row","type":"table"},{"anchor":"Version-Management","level":2,"text":"Version Management","type":"heading"},{"inlineContent":[{"type":"text","text":"When publishing versions:"}],"type":"paragraph"},{"items":[{"content":[{"inlineContent":[{"type":"text","text":"Once a version is published, it cannot be changed"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"text":"You can publish new versions with increasing version numbers","type":"text"}]}]},{"content":[{"inlineContent":[{"text":"Follow semantic versioning guidelines for compatibility","type":"text"}],"type":"paragraph"}]}],"type":"unorderedList"},{"text":"Next Steps","anchor":"Next-Steps","type":"heading","level":2},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"text":"Explore endpoint details for more information on the publishing process","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Learn about managing package releases and metadata"}]}]}],"type":"unorderedList"}]}],"sections":[],"metadata":{"title":"Publishing Packages","roleHeading":"Article","role":"article","modules":[{"name":"Registry API"}]},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"kind":"article","identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","interfaceLanguage":"openapi"},"schemaVersion":{"major":0,"minor":3,"patch":0},"seeAlsoSections":[{"generated":true,"anchor":"Guides","title":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"]}],"abstract":[{"type":"text","text":"Learn how to publish your Swift packages to a package registry."}],"references":{"https://semver.org/":{"type":"link","title":"Semantic Versioning","titleInlineContent":[{"type":"text","text":"Semantic Versioning"}],"url":"https:\/\/semver.org\/","identifier":"https:\/\/semver.org\/"},"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/ratelimiting.json b/docs/data/documentation/registry-api/ratelimiting.json new file mode 100644 index 00000000..91446355 --- /dev/null +++ b/docs/data/documentation/registry-api/ratelimiting.json @@ -0,0 +1 @@ +{"schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"seeAlsoSections":[{"title":"Related Documentation","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"anchor":"Related-Documentation"},{"generated":true,"title":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"anchor":"Guides"}],"primaryContentSections":[{"kind":"content","content":[{"level":2,"text":"Overview","type":"heading","anchor":"Overview"},{"type":"paragraph","inlineContent":[{"text":"The Swift Package Registry API implements rate limiting to ensure fair usage and system stability. Understanding these limits and implementing proper handling will improve your application’s reliability when interacting with the registry.","type":"text"}]},{"text":"Rate Limiting Headers","anchor":"Rate-Limiting-Headers","type":"heading","level":2},{"inlineContent":[{"type":"text","text":"When you make requests to the API, the following headers are included in every response:"}],"type":"paragraph"},{"header":"row","rows":[[[{"inlineContent":[{"type":"text","text":"Header"}],"type":"paragraph"}],[{"inlineContent":[{"type":"text","text":"Description"}],"type":"paragraph"}]],[[{"inlineContent":[{"type":"codeVoice","code":"RateLimit-Limit"}],"type":"paragraph"}],[{"inlineContent":[{"type":"text","text":"Maximum number of requests allowed in the current time window"}],"type":"paragraph"}]],[[{"inlineContent":[{"type":"codeVoice","code":"RateLimit-Remaining"}],"type":"paragraph"}],[{"inlineContent":[{"text":"Number of requests remaining in the current time window","type":"text"}],"type":"paragraph"}]],[[{"inlineContent":[{"type":"codeVoice","code":"RateLimit-Reset"}],"type":"paragraph"}],[{"inlineContent":[{"type":"text","text":"Time when the current rate limit window resets (UTC epoch seconds)"}],"type":"paragraph"}]]],"type":"table"},{"type":"codeListing","code":["\/\/ Example: Checking rate limiting headers","func checkRateLimits(from response: HTTPURLResponse) -> RateLimitInfo {"," let limit = Int(response.value(forHTTPHeaderField: \"RateLimit-Limit\") ?? \"60\") ?? 60"," let remaining = Int(response.value(forHTTPHeaderField: \"RateLimit-Remaining\") ?? \"0\") ?? 0"," let resetTime = TimeInterval(response.value(forHTTPHeaderField: \"RateLimit-Reset\") ?? \"0\") ?? 0"," "," return RateLimitInfo("," limit: limit, "," remaining: remaining, "," resetDate: Date(timeIntervalSince1970: resetTime)"," )","}"],"syntax":"swift"},{"type":"heading","level":2,"text":"Rate Limit Tiers","anchor":"Rate-Limit-Tiers"},{"type":"paragraph","inlineContent":[{"text":"The API has different rate limit tiers depending on your authentication status:","type":"text"}]},{"type":"table","rows":[[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Tier"}]}],[{"type":"paragraph","inlineContent":[{"text":"Requests per Hour","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"text":"Description","type":"text"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Anonymous"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"60"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Unauthenticated requests"}]}]],[[{"type":"paragraph","inlineContent":[{"type":"text","text":"Authenticated"}]}],[{"type":"paragraph","inlineContent":[{"text":"1,000","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Requests with a valid user token"}]}]],[[{"type":"paragraph","inlineContent":[{"text":"Service","type":"text"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"5,000"}]}],[{"type":"paragraph","inlineContent":[{"type":"text","text":"Requests with a service token"}]}]]],"header":"row"},{"type":"heading","level":2,"text":"Handling Rate Limiting","anchor":"Handling-Rate-Limiting"},{"type":"paragraph","inlineContent":[{"type":"text","text":"When you exceed your rate limit, the API responds with a "},{"type":"codeVoice","code":"429 Too Many Requests"},{"type":"text","text":" status code and includes a "},{"type":"codeVoice","code":"Retry-After"},{"type":"text","text":" header indicating how many seconds to wait before retrying."}]},{"type":"codeListing","code":["\/\/ Example: Rate limit handling with backoff","func makeRegistryRequest(_ request: URLRequest) async throws -> Data {"," let session = URLSession.shared"," "," do {"," let (data, response) = try await session.data(for: request)"," guard let httpResponse = response as? HTTPURLResponse else {"," throw RegistryError.invalidResponse"," }"," "," if httpResponse.statusCode == 429 {"," \/\/ We hit a rate limit"," if let retryAfterString = httpResponse.value(forHTTPHeaderField: \"Retry-After\"),"," let retryAfter = TimeInterval(retryAfterString) {"," "," \/\/ Wait for the specified time before retrying"," try await Task.sleep(nanoseconds: UInt64(retryAfter * 1_000_000_000))"," "," \/\/ Retry the request"," return try await makeRegistryRequest(request)"," } else {"," throw RegistryError.rateLimitExceeded"," }"," }"," "," \/\/ Handle other status codes..."," "," return data"," } catch {"," \/\/ Handle network errors"," throw error"," }","}"],"syntax":"swift"},{"type":"heading","level":2,"text":"Best Practices","anchor":"Best-Practices"},{"type":"heading","level":3,"text":"1. Monitor Your Usage","anchor":"1-Monitor-Your-Usage"},{"type":"paragraph","inlineContent":[{"type":"text","text":"Always check rate limit headers and keep track of your consumption to avoid hitting limits:"}]},{"type":"codeListing","code":["class RegistryClient {"," private var rateLimitInfo: RateLimitInfo?"," "," func updateRateLimitInfo(from response: HTTPURLResponse) {"," rateLimitInfo = checkRateLimits(from: response)"," "," \/\/ Log when close to limit"," if let info = rateLimitInfo, info.remaining < info.limit * 0.1 {"," print(\"Warning: Rate limit nearly reached. \\(info.remaining) requests remaining until \\(info.resetDate)\")"," }"," }"," "," \/\/ Other methods...","}"],"syntax":"swift"},{"type":"heading","level":3,"text":"2. Implement Caching","anchor":"2-Implement-Caching"},{"type":"paragraph","inlineContent":[{"text":"Reduce your API calls by caching responses appropriately:","type":"text"}]},{"type":"codeListing","code":["class RegistryClient {"," private var cache = NSCache()"," "," func fetchPackageMetadata(scope: String, name: String) async throws -> PackageMetadata {"," let cacheKey = \"\\(scope)\/\\(name)\" as NSString"," "," \/\/ Check cache first"," if let cachedResponse = cache.object(forKey: cacheKey),"," cachedResponse.expirationDate > Date() {"," return cachedResponse.metadata"," }"," "," \/\/ Make API request"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\")!"," let (data, response) = try await URLSession.shared.data(from: url)"," "," \/\/ Update rate limit info"," if let httpResponse = response as? HTTPURLResponse {"," updateRateLimitInfo(from: httpResponse)"," }"," "," \/\/ Parse and cache response"," let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)"," "," \/\/ Cache for 5 minutes"," let cachedResponse = CachedResponse("," metadata: metadata,"," expirationDate: Date().addingTimeInterval(5 * 60)"," )"," cache.setObject(cachedResponse, forKey: cacheKey)"," "," return metadata"," }","}"],"syntax":"swift"},{"type":"heading","level":3,"text":"3. Use Conditional Requests","anchor":"3-Use-Conditional-Requests"},{"type":"paragraph","inlineContent":[{"type":"text","text":"When appropriate, use ETag or Last-Modified headers to make conditional requests:"}]},{"type":"codeListing","code":["func fetchPackageWithETag(scope: String, name: String) async throws -> PackageMetadata {"," let url = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\")!"," var request = URLRequest(url: url)"," "," \/\/ Add ETag if we have it"," if let etag = etagStorage[\"\\(scope)\/\\(name)\"] {"," request.addValue(etag, forHTTPHeaderField: \"If-None-Match\")"," }"," "," let (data, response) = try await URLSession.shared.data(for: request)"," guard let httpResponse = response as? HTTPURLResponse else {"," throw RegistryError.invalidResponse"," }"," "," \/\/ Update rate limit info"," updateRateLimitInfo(from: httpResponse)"," "," \/\/ Store new ETag if present"," if let newETag = httpResponse.value(forHTTPHeaderField: \"ETag\") {"," etagStorage[\"\\(scope)\/\\(name)\"] = newETag"," }"," "," \/\/ If 304 Not Modified, return cached data"," if httpResponse.statusCode == 304 {"," guard let cachedMetadata = metadataCache[\"\\(scope)\/\\(name)\"] else {"," throw RegistryError.cacheInconsistency"," }"," return cachedMetadata"," }"," "," \/\/ Process new data"," let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)"," metadataCache[\"\\(scope)\/\\(name)\"] = metadata"," return metadata","}"],"syntax":"swift"},{"type":"heading","level":3,"text":"4. Batch Requests When Possible","anchor":"4-Batch-Requests-When-Possible"},{"type":"paragraph","inlineContent":[{"text":"Instead of making multiple small requests, batch them when the API supports it:","type":"text"}]},{"type":"codeListing","code":["\/\/ Instead of fetching packages one by one","func fetchMultiplePackageIdentifiers(query: String) async throws -> [Identifier] {"," \/\/ Use the search endpoint with multiple criteria"," let url = URL(string: \"https:\/\/registry.example.com\/identifiers?query=\\(query)&limit=100\")!"," let (data, response) = try await URLSession.shared.data(from: url)"," "," if let httpResponse = response as? HTTPURLResponse {"," updateRateLimitInfo(from: httpResponse)"," }"," "," return try JSONDecoder().decode([Identifier].self, from: data)","}"],"syntax":"swift"},{"type":"heading","level":3,"text":"5. Queue and Prioritize Requests","anchor":"5-Queue-and-Prioritize-Requests"},{"type":"paragraph","inlineContent":[{"type":"text","text":"When working with many requests, implement a queue system that respects rate limits:"}]},{"code":["class RegistryRequestQueue {"," private var queue = [RegistryRequest]()"," private var isProcessing = false"," "," func addRequest(_ request: RegistryRequest) {"," queue.append(request)"," processQueue()"," }"," "," private func processQueue() {"," guard !isProcessing, !queue.isEmpty else { return }"," "," isProcessing = true"," "," Task {"," repeat {"," \/\/ Sort queue by priority"," queue.sort { $0.priority > $1.priority }"," "," \/\/ Take the next request"," let nextRequest = queue.removeFirst()"," "," do {"," let _ = try await executeRequest(nextRequest)"," \/\/ Handle success"," await nextRequest.completion(.success(()))"," } catch {"," \/\/ Handle error"," await nextRequest.completion(.failure(error))"," "," if let registryError = error as? RegistryError, "," case .rateLimitExceeded = registryError {"," \/\/ Wait before continuing if rate limited"," try? await Task.sleep(nanoseconds: 5_000_000_000)"," }"," }"," } while !queue.isEmpty"," "," isProcessing = false"," }"," }"," "," \/\/ Other methods...","}"],"type":"codeListing","syntax":"swift"}]}],"metadata":{"roleHeading":"Article","title":"Rate Limiting","modules":[{"name":"Registry API"}],"role":"article"},"sections":[],"kind":"article","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"references":{"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"}}} \ No newline at end of file diff --git a/docs/data/documentation/registry-api/security.json b/docs/data/documentation/registry-api/security.json new file mode 100644 index 00000000..dedbb3f7 --- /dev/null +++ b/docs/data/documentation/registry-api/security.json @@ -0,0 +1 @@ +{"primaryContentSections":[{"kind":"content","content":[{"text":"Overview","anchor":"Overview","level":2,"type":"heading"},{"inlineContent":[{"type":"text","text":"Security is a critical aspect of package management. This guide covers best practices for securely interacting with the Swift Package Registry API, protecting sensitive information, and verifying package authenticity."}],"type":"paragraph"},{"text":"Secure Authentication","anchor":"Secure-Authentication","level":2,"type":"heading"},{"text":"Token Management","anchor":"Token-Management","level":3,"type":"heading"},{"inlineContent":[{"type":"text","text":"When working with authentication tokens:"}],"type":"paragraph"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"text":"Never hardcode tokens","type":"text"}],"type":"strong"},{"text":" in your application source code","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Use environment variables, secure storage, or a secrets management solution"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"text":"Rotate tokens regularly following the principle of least privilege","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"text","text":"Set appropriate token expiration times"}],"type":"paragraph"}]}],"type":"unorderedList"},{"code":["\/\/ ❌ INCORRECT: Hardcoded token","let apiToken = \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...\"","","\/\/ ✅ BETTER: Load from secure storage","let apiToken = try KeychainManager.getToken(forService: \"registry-api\")","","\/\/ ✅ BEST: Use a token provider with automatic rotation","let apiToken = try await TokenProvider.shared.getValidToken()"],"syntax":"swift","type":"codeListing"},{"text":"Secure Token Storage","anchor":"Secure-Token-Storage","level":3,"type":"heading"},{"inlineContent":[{"text":"Store your tokens securely using platform-appropriate mechanisms:","type":"text"}],"type":"paragraph"},{"code":["\/\/ Example: Secure token storage using keychain on Apple platforms","class KeychainTokenStorage: TokenStorage {"," func saveToken(_ token: String, forService service: String) throws {"," let query: [String: Any] = ["," kSecClass as String: kSecClassGenericPassword,"," kSecAttrService as String: service,"," kSecAttrAccount as String: \"api-token\","," kSecValueData as String: Data(token.utf8),"," kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly"," ]"," "," \/\/ Delete any existing token"," SecItemDelete(query as CFDictionary)"," "," \/\/ Save the new token"," let status = SecItemAdd(query as CFDictionary, nil)"," guard status == errSecSuccess else {"," throw TokenStorageError.saveFailed(status)"," }"," }"," "," func getToken(forService service: String) throws -> String {"," let query: [String: Any] = ["," kSecClass as String: kSecClassGenericPassword,"," kSecAttrService as String: service,"," kSecAttrAccount as String: \"api-token\","," kSecReturnData as String: true,"," kSecMatchLimit as String: kSecMatchLimitOne"," ]"," "," var result: AnyObject?"," let status = SecItemCopyMatching(query as CFDictionary, &result)"," "," guard status == errSecSuccess else {"," throw TokenStorageError.retrievalFailed(status)"," }"," "," guard let tokenData = result as? Data,"," let token = String(data: tokenData, encoding: .utf8) else {"," throw TokenStorageError.invalidData"," }"," "," return token"," }","}"],"syntax":"swift","type":"codeListing"},{"text":"Package Integrity Verification","anchor":"Package-Integrity-Verification","level":2,"type":"heading"},{"inlineContent":[{"type":"text","text":"Always verify package integrity using the provided checksums:"}],"type":"paragraph"},{"code":["\/\/ Example: Verify package checksum","func verifyPackageIntegrity(packageData: Data, expectedChecksum: String) throws -> Bool {"," \/\/ Calculate the SHA-256 hash of the package data"," let computedHash = SHA256.hash(data: packageData)"," let computedChecksum = computedHash.compactMap { String(format: \"%02x\", $0) }.joined()"," "," \/\/ Compare with the expected checksum (case-insensitive)"," return computedChecksum.lowercased() == expectedChecksum.lowercased()","}","","\/\/ Usage example","func downloadAndVerifyPackage(scope: String, name: String, version: String) async throws -> Data {"," \/\/ 1. Get package metadata with checksum information"," let metadataURL = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\/\\(version)\")!"," let (metadataData, _) = try await URLSession.shared.data(from: metadataURL)"," let release = try JSONDecoder().decode(ReleaseResource.self, from: metadataData)"," "," \/\/ 2. Find the source archive resource and its checksum"," guard let sourceArchive = release.resources.first(where: { $0.name == \"source-archive\" }),"," let checksum = sourceArchive.checksum else {"," throw VerificationError.missingChecksumInfo"," }"," "," \/\/ 3. Download the package"," let packageURL = URL(string: \"https:\/\/registry.example.com\/\\(scope)\/\\(name)\/\\(version).zip\")!"," let (packageData, _) = try await URLSession.shared.data(from: packageURL)"," "," \/\/ 4. Verify the integrity"," guard try verifyPackageIntegrity(packageData: packageData, expectedChecksum: checksum) else {"," throw VerificationError.checksumMismatch"," }"," "," return packageData","}"],"syntax":"swift","type":"codeListing"},{"text":"Transport Security","anchor":"Transport-Security","level":2,"type":"heading"},{"inlineContent":[{"type":"text","text":"Always use secure connections when communicating with the registry:"}],"type":"paragraph"},{"items":[{"content":[{"inlineContent":[{"type":"text","text":"Ensure your URL connections use HTTPS"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Verify TLS certificates"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Enable certificate pinning for critical applications"}]}]}],"type":"unorderedList"},{"code":["\/\/ Example: URL Session configuration with certificate pinning","func createSecureURLSession() -> URLSession {"," let configuration = URLSessionConfiguration.default"," "," \/\/ Ensure only HTTPS connections are allowed"," configuration.tlsMinimumSupportedProtocolVersion = .TLSv12"," "," \/\/ Create a delegate for certificate pinning"," let delegate = CertificatePinningDelegate()"," "," return URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)","}","","class CertificatePinningDelegate: NSObject, URLSessionDelegate {"," func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, "," completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {"," "," guard let serverTrust = challenge.protectionSpace.serverTrust,"," challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,"," challenge.protectionSpace.host.hasSuffix(\"registry.example.com\") else {"," \/\/ Reject invalid challenges"," completionHandler(.cancelAuthenticationChallenge, nil)"," return"," }"," "," \/\/ Get the server's certificate data"," let serverCertificatesData = certificateData(for: serverTrust)"," "," \/\/ Get the pinned certificate data"," guard let pinnedCertificateData = loadPinnedCertificateData() else {"," completionHandler(.cancelAuthenticationChallenge, nil)"," return"," }"," "," \/\/ Compare certificates"," if serverCertificatesData.contains(pinnedCertificateData) {"," \/\/ Certificate matched, proceed with connection"," let credential = URLCredential(trust: serverTrust)"," completionHandler(.useCredential, credential)"," } else {"," \/\/ Certificate mismatch, cancel connection"," completionHandler(.cancelAuthenticationChallenge, nil)"," }"," }"," "," \/\/ Helper methods...","}"],"syntax":"swift","type":"codeListing"},{"text":"Secure Dependency Resolution","anchor":"Secure-Dependency-Resolution","level":2,"type":"heading"},{"inlineContent":[{"type":"text","text":"Follow these guidelines when resolving package dependencies:"}],"type":"paragraph"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Define exact versions"}]},{"type":"text","text":" when possible to prevent unexpected changes"}]}]},{"content":[{"inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Use package checksums"}]},{"type":"text","text":" to validate package integrity during resolution"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"text":"Lock dependencies","type":"text"}]},{"type":"text","text":" in your Package.resolved file"}]}]},{"content":[{"inlineContent":[{"type":"strong","inlineContent":[{"text":"Audit dependencies","type":"text"}]},{"type":"text","text":" regularly for vulnerabilities"}],"type":"paragraph"}]}],"type":"orderedList"},{"code":["\/\/ Example: Package.swift with pinned dependencies","dependencies: ["," .package("," url: \"https:\/\/github.com\/apple\/swift-algorithms\","," exact: \"1.0.0\" \/\/ Pin to exact version"," ),"," .package("," url: \"https:\/\/github.com\/apple\/swift-collections\","," revision: \"a281e8b846a354fca484a08abbc657dfe39c9b1c\" \/\/ Pin to specific commit"," )","]"],"syntax":"swift","type":"codeListing"},{"text":"Content Security","anchor":"Content-Security","level":2,"type":"heading"},{"text":"XSS Protection","anchor":"XSS-Protection","level":3,"type":"heading"},{"inlineContent":[{"type":"text","text":"When displaying package metadata or README content in your application:"}],"type":"paragraph"},{"items":[{"content":[{"inlineContent":[{"type":"text","text":"Always sanitize content before rendering"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Use a secure rendering library that handles escaping"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"text","text":"Consider Content Security Policy (CSP) for web applications"}]}]}],"type":"orderedList"},{"code":["\/\/ Example: Content sanitization for package metadata","func sanitizeHTMLContent(_ html: String) -> String {"," \/\/ Use a proper HTML sanitizer library here"," \/\/ This is a simplified example"," let disallowedTags = [\"script\", \"iframe\", \"object\", \"embed\"]"," "," var sanitized = html"," for tag in disallowedTags {"," let openTagPattern = \"<\\(tag)[^>]*>\""," let closeTagPattern = \"<\/\\(tag)>\""," "," sanitized = sanitized.replacingOccurrences(of: openTagPattern, "," with: \"\", "," options: .regularExpression)"," sanitized = sanitized.replacingOccurrences(of: closeTagPattern, "," with: \"\", "," options: .regularExpression)"," }"," "," return sanitized","}"],"syntax":"swift","type":"codeListing"},{"text":"Input Validation","anchor":"Input-Validation","level":3,"type":"heading"},{"inlineContent":[{"type":"text","text":"Always validate input parameters before sending them to the API:"}],"type":"paragraph"},{"code":["\/\/ Example: Parameter validation","func validatePackageParameters(scope: String, name: String, version: String?) throws {"," \/\/ Validate scope"," guard scope.range(of: \"^[a-zA-Z0-9][-a-zA-Z0-9_.]*$\", options: .regularExpression) != nil else {"," throw ValidationError.invalidScope"," }"," "," \/\/ Validate name"," guard name.range(of: \"^[a-zA-Z0-9][-a-zA-Z0-9_.]*$\", options: .regularExpression) != nil else {"," throw ValidationError.invalidName"," }"," "," \/\/ Validate version if provided"," if let version = version {"," guard version.range(of: \"^\\\\d+\\\\.\\\\d+\\\\.\\\\d+$\", options: .regularExpression) != nil else {"," throw ValidationError.invalidVersion"," }"," }","}"],"syntax":"swift","type":"codeListing"},{"text":"Additional Security Measures","anchor":"Additional-Security-Measures","level":2,"type":"heading"},{"text":"API Key Rotation","anchor":"API-Key-Rotation","level":3,"type":"heading"},{"inlineContent":[{"text":"Implement regular key rotation to minimize risk:","type":"text"}],"type":"paragraph"},{"code":["\/\/ Example: Token rotation schedule","class TokenRotationManager {"," private let tokenStorage: TokenStorage"," private let tokenProvider: TokenProvider"," "," \/\/ Rotate tokens every 30 days"," private let rotationInterval: TimeInterval = 30 * 24 * 60 * 60"," "," func scheduleRotation() {"," \/\/ Check when the current token was created"," let currentTokenCreationDate = tokenStorage.getTokenCreationDate()"," "," \/\/ Calculate time until next rotation"," let timeUntilRotation = max(0, "," (currentTokenCreationDate.addingTimeInterval(rotationInterval).timeIntervalSince1970 - "," Date().timeIntervalSince1970))"," "," \/\/ Schedule rotation"," DispatchQueue.global().asyncAfter(deadline: .now() + timeUntilRotation) { [weak self] in"," self?.rotateToken()"," }"," }"," "," private func rotateToken() {"," do {"," \/\/ Generate new token"," let newToken = try tokenProvider.generateNewToken()"," "," \/\/ Save the new token"," try tokenStorage.saveToken(newToken)"," "," \/\/ Revoke the old token"," try tokenProvider.revokeToken(tokenStorage.getOldToken())"," "," \/\/ Schedule the next rotation"," scheduleRotation()"," } catch {"," \/\/ Handle rotation failure"," \/\/ Log error and retry after a short delay"," }"," }","}"],"syntax":"swift","type":"codeListing"},{"text":"Logging and Monitoring","anchor":"Logging-and-Monitoring","level":3,"type":"heading"},{"inlineContent":[{"text":"Implement secure logging practices:","type":"text"}],"type":"paragraph"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"text":"Never log sensitive information such as tokens or private package data","type":"text"}]}]},{"content":[{"inlineContent":[{"text":"Use structured logging for easy analysis","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"text":"Implement monitoring for unusual access patterns","type":"text"}],"type":"paragraph"}]}],"type":"unorderedList"},{"code":["\/\/ Example: Secure logging","enum LogLevel: String {"," case debug, info, warning, error","}","","class SecureLogger {"," static func log(_ message: String, level: LogLevel = .info, sensitiveData: Bool = false) {"," \/\/ Don't log sensitive data in production"," #if DEBUG"," let logEntry = \"[\\(level.rawValue.uppercased())] \\(Date()): \\(message)\""," print(logEntry)"," #else"," if !sensitiveData {"," let logEntry = \"[\\(level.rawValue.uppercased())] \\(Date()): \\(message)\""," print(logEntry)"," \/\/ In a real implementation, send to logging service"," }"," #endif"," }"," "," static func logAPIRequest(endpoint: String, statusCode: Int?, error: Error?) {"," var message = \"API Request: \\(endpoint)\""," "," if let statusCode = statusCode {"," message += \", Status: \\(statusCode)\""," }"," "," if let error = error {"," message += \", Error: \\(error.localizedDescription)\""," }"," "," log(message)"," }","}"],"syntax":"swift","type":"codeListing"}]}],"kind":"article","abstract":[{"type":"text","text":"Learn how to securely interact with the Swift Package Registry API."}],"schemaVersion":{"patch":0,"major":0,"minor":3},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","interfaceLanguage":"openapi"},"seeAlsoSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes"],"title":"Related Documentation","anchor":"Related-Documentation"},{"anchor":"Guides","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"title":"Guides","generated":true}],"metadata":{"title":"Security Best Practices","roleHeading":"Article","modules":[{"name":"Registry API"}],"role":"article"},"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi.json b/docs/data/documentation/registryapi.json new file mode 100644 index 00000000..61693315 --- /dev/null +++ b/docs/data/documentation/registryapi.json @@ -0,0 +1 @@ +{"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","interfaceLanguage":"openapi"},"metadata":{"symbolKind":"module","roleHeading":"Swift Package Registry API","modules":[{"name":"Registry API"}],"externalID":"RegistryAPI","title":"Registry API","role":"collection"},"topicSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/GettingStarted"],"title":"API Endpoints","anchor":"API-Endpoints"},{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"title":"Data Models","anchor":"Data-Models"},{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance"],"title":"Guides","anchor":"Guides"},{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login"],"title":"Protocols","generated":true,"anchor":"Protocols"}],"abstract":[{"text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages.","type":"text"}],"schemaVersion":{"minor":3,"major":0,"patch":0},"primaryContentSections":[{"kind":"content","content":[{"type":"heading","anchor":"Overview","level":2,"text":"Overview"},{"inlineContent":[{"text":"The Swift Package Registry API provides a robust interface for package management that follows open standards. Using this API, you can:","type":"text"}],"type":"paragraph"},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Discover"}]},{"type":"text","text":" packages through search and metadata"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Retrieve"}]},{"type":"text","text":" package releases including source code and manifests"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"text":"Publish","type":"text"}],"type":"strong"},{"type":"text","text":" your own packages for others to use"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"inlineContent":[{"text":"Authenticate","type":"text"}],"type":"strong"},{"text":" to access private packages or perform privileged operations","type":"text"}]}]}]},{"inlineContent":[],"type":"paragraph"},{"inlineContent":[{"text":"The API follows RESTful principles with well-defined endpoints for each resource type. All requests and responses use standard HTTP methods and status codes, with JSON-formatted data.","type":"text"}],"type":"paragraph"},{"type":"codeListing","code":["\/\/ Example: Retrieve package metadata","let url = URL(string: \"https:\/\/registry.example.com\/mona\/LinkedList\")!","let (data, response) = try await URLSession.shared.data(from: url)","let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)","","print(\"Package: \\(metadata.name)\")","print(\"Latest version: \\(metadata.latestVersion)\")","print(\"Available versions: \\(metadata.versions.joined(separator: \", \"))\")"],"syntax":"swift"}]}],"hierarchy":{"paths":[[]]},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi"]}],"sections":[],"kind":"symbol","references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip":{"abstract":[],"type":"topic","role":"symbol","navigatorTitle":[{"text":"\/{scope}\/{name}\/{version}.zip","kind":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version_.zip","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","title":"\/{scope}\/{name}\/{version}.zip"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_identifiers":{"abstract":[],"navigatorTitle":[{"text":"\/identifiers","kind":"text"}],"title":"\/identifiers","url":"\/documentation\/registryapi\/_identifiers","kind":"symbol","type":"topic","role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift":{"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version__package.swift","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}\/Package.swift"}],"role":"symbol","title":"\/{scope}\/{name}\/{version}\/Package.swift","type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Security":{"role":"article","type":"topic","abstract":[{"text":"Learn how to securely interact with the Swift Package Registry API.","type":"text"}],"url":"\/documentation\/registry-api\/security","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Security","kind":"article","title":"Security Best Practices"},"doc://com.example.RegistryAPI/documentation/Registry-API/Performance":{"title":"Performance Optimization","kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Performance","url":"\/documentation\/registry-api\/performance","abstract":[{"type":"text","text":"Learn how to optimize your Swift Package Registry API usage for maximum performance."}],"type":"topic","role":"article"},"doc://com.example.RegistryAPI/documentation/Registry-API/GettingStarted":{"abstract":[{"type":"text","text":"Learn how to use the Swift Package Registry API to discover and retrieve packages."}],"role":"article","kind":"article","url":"\/documentation\/registry-api\/gettingstarted","title":"Getting Started with Swift Package Registry","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/GettingStarted","type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/Publishing":{"title":"Publishing Packages","type":"topic","kind":"article","abstract":[{"text":"Learn how to publish your Swift packages to a package registry.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Publishing","role":"article","url":"\/documentation\/registry-api\/publishing"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name_":{"abstract":[],"url":"\/documentation\/registryapi\/__scope___name_","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_","kind":"symbol","role":"symbol","type":"topic","title":"\/{scope}\/{name}"},"doc://com.example.RegistryAPI/documentation/Registry-API/Authentication":{"type":"topic","title":"Authentication","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/Authentication","kind":"article","role":"article","url":"\/documentation\/registry-api\/authentication","abstract":[{"type":"text","text":"Learn how to authenticate with the Swift Package Registry API for accessing private packages and publishing."}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","type":"topic","abstract":[],"url":"\/documentation\/registryapi\/_login","title":"\/login","navigatorTitle":[{"kind":"text","text":"\/login"}],"kind":"symbol","role":"symbol"},"doc://com.example.RegistryAPI/documentation/Registry-API/RateLimiting":{"role":"article","url":"\/documentation\/registry-api\/ratelimiting","abstract":[{"type":"text","text":"Learn about the Swift Package Registry’s rate limiting mechanisms and how to optimize your usage."}],"kind":"article","title":"Rate Limiting","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/RateLimiting"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/Registry-API/ErrorCodes":{"abstract":[{"type":"text","text":"Understand how the Swift Package Registry API communicates errors and how to handle them."}],"kind":"article","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/Registry-API\/ErrorCodes","url":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"topic","role":"article"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name_.json b/docs/data/documentation/registryapi/__scope___name_.json new file mode 100644 index 00000000..6a011e9f --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name_.json @@ -0,0 +1 @@ +{"schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_","interfaceLanguage":"openapi"},"metadata":{"symbolKind":"protocol","navigatorTitle":[{"text":"\/{scope}\/{name}","kind":"text"}],"roleHeading":"Path","externalID":"path:\/{scope}\/{name}","modules":[{"name":"Registry API"}],"title":"\/{scope}\/{name}","role":"symbol"},"kind":"symbol","sections":[],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name_"]}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"topicSections":[{"title":"Instance Methods","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_\/get"],"anchor":"Instance-Methods","generated":true}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name_/get":{"fragments":[{"text":"GET","kind":"text"}],"title":"List package releases","url":"\/documentation\/registryapi\/__scope___name_\/get","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}],"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_\/get","kind":"symbol","navigatorTitle":[{"text":"GET \/{scope}\/{name}","kind":"text"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name_":{"abstract":[],"url":"\/documentation\/registryapi\/__scope___name_","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_","kind":"symbol","role":"symbol","type":"topic","title":"\/{scope}\/{name}"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name_/get.json b/docs/data/documentation/registryapi/__scope___name_/get.json new file mode 100644 index 00000000..c09cfc6a --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name_/get.json @@ -0,0 +1 @@ +{"variants":[{"paths":["\/documentation\/registryapi\/__scope___name_\/get"],"traits":[{"interfaceLanguage":"openapi"}]}],"schemaVersion":{"patch":0,"major":0,"minor":3},"metadata":{"fragments":[{"text":"GET","kind":"text"}],"navigatorTitle":[{"text":"GET \/{scope}\/{name}","kind":"text"}],"role":"symbol","roleHeading":"HTTP GET","externalID":"operation:get:\/{scope}\/{name}","modules":[{"name":"Registry API"}],"title":"List package releases","symbolKind":"method"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_"]]},"primaryContentSections":[{"kind":"content","content":[{"anchor":"discussion","type":"heading","text":"Discussion","level":2},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"code":"415","type":"codeVoice"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"200"},{"type":"text","text":": Retrieve a list of all available releases for a given package"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"401"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"404"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"400"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"429","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]}]}]}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_\/get","interfaceLanguage":"openapi"},"sections":[],"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}],"kind":"symbol","topicSections":[{"anchor":"Structures","generated":true,"title":"Structures","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name_/get":{"fragments":[{"text":"GET","kind":"text"}],"title":"List package releases","url":"\/documentation\/registryapi\/__scope___name_\/get","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}],"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_\/get","kind":"symbol","navigatorTitle":[{"text":"GET \/{scope}\/{name}","kind":"text"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name_":{"abstract":[],"url":"\/documentation\/registryapi\/__scope___name_","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name_","kind":"symbol","role":"symbol","type":"topic","title":"\/{scope}\/{name}"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/404":{"abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","title":"404 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","type":"topic","title":"401 Response","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_.json b/docs/data/documentation/registryapi/__scope___name___version_.json new file mode 100644 index 00000000..227b626d --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_.json @@ -0,0 +1 @@ +{"schemaVersion":{"major":0,"patch":0,"minor":3},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"topicSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"],"title":"Instance Methods","anchor":"Instance-Methods","generated":true}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_"]}],"kind":"symbol","metadata":{"symbolKind":"protocol","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"roleHeading":"Path","role":"symbol","externalID":"path:\/{scope}\/{name}\/{version}","modules":[{"name":"Registry API"}],"title":"\/{scope}\/{name}\/{version}"},"sections":[],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_.zip.json b/docs/data/documentation/registryapi/__scope___name___version_.zip.json new file mode 100644 index 00000000..1978798f --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_.zip.json @@ -0,0 +1 @@ +{"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","interfaceLanguage":"openapi"},"schemaVersion":{"patch":0,"major":0,"minor":3},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_.zip"]}],"metadata":{"role":"symbol","symbolKind":"protocol","roleHeading":"Path","modules":[{"name":"Registry API"}],"title":"\/{scope}\/{name}\/{version}.zip","navigatorTitle":[{"text":"\/{scope}\/{name}\/{version}.zip","kind":"text"}],"externalID":"path:\/{scope}\/{name}\/{version}.zip"},"kind":"symbol","sections":[],"topicSections":[{"anchor":"Instance-Methods","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get"],"title":"Instance Methods","generated":true}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip":{"abstract":[],"type":"topic","role":"symbol","navigatorTitle":[{"text":"\/{scope}\/{name}\/{version}.zip","kind":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version_.zip","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","title":"\/{scope}\/{name}\/{version}.zip"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip/get":{"fragments":[{"kind":"text","text":"GET"}],"navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}.zip"}],"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_.zip\/get","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get","title":"Download source archive for a package release","abstract":[{"type":"strong","inlineContent":[{"text":"Responses:","type":"text"}]}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_.zip/get.json b/docs/data/documentation/registryapi/__scope___name___version_.zip/get.json new file mode 100644 index 00000000..c18c1be3 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_.zip/get.json @@ -0,0 +1 @@ +{"topicSections":[{"generated":true,"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429"],"anchor":"Structures","title":"Structures"}],"primaryContentSections":[{"content":[{"text":"Discussion","level":2,"type":"heading","anchor":"discussion"},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"400"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"401"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"inlineContent":[{"code":"415","type":"codeVoice"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"303"},{"type":"text","text":": See other - download from the URL in the Location header."}]}]},{"content":[{"inlineContent":[{"code":"404","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"429"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"200"},{"type":"text","text":": Download the source archive for the specified package release"}],"type":"paragraph"}]}]}],"kind":"content"}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip"]]},"metadata":{"externalID":"operation:get:\/{scope}\/{name}\/{version}.zip","role":"symbol","title":"Download source archive for a package release","fragments":[{"kind":"text","text":"GET"}],"symbolKind":"method","roleHeading":"HTTP GET","modules":[{"name":"Registry API"}],"navigatorTitle":[{"text":"GET \/{scope}\/{name}\/{version}.zip","kind":"text"}]},"abstract":[{"type":"strong","inlineContent":[{"text":"Responses:","type":"text"}]}],"sections":[],"schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get"},"kind":"symbol","variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version_.zip\/get"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"title":"401 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip/get":{"fragments":[{"kind":"text","text":"GET"}],"navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}.zip"}],"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_.zip\/get","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get","title":"Download source archive for a package release","abstract":[{"type":"strong","inlineContent":[{"text":"Responses:","type":"text"}]}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/404":{"abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","title":"404 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip":{"abstract":[],"type":"topic","role":"symbol","navigatorTitle":[{"text":"\/{scope}\/{name}\/{version}.zip","kind":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version_.zip","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","title":"\/{scope}\/{name}\/{version}.zip"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/303":{"title":"303 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"303 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303","abstract":[{"text":"See other - download from the URL in the Location header.","type":"text"}],"kind":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/get.json b/docs/data/documentation/registryapi/__scope___name___version_/get.json new file mode 100644 index 00000000..88c0f9c4 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/get.json @@ -0,0 +1 @@ +{"topicSections":[{"generated":true,"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429"],"anchor":"Structures","title":"Structures"}],"schemaVersion":{"major":0,"minor":3,"patch":0},"metadata":{"role":"symbol","externalID":"operation:get:\/{scope}\/{name}\/{version}","navigatorTitle":[{"text":"GET \/{scope}\/{name}\/{version}","kind":"text"}],"title":"Fetch metadata for a package release","roleHeading":"HTTP GET","fragments":[{"text":"GET","kind":"text"}],"symbolKind":"method","modules":[{"name":"Registry API"}]},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/get"]}],"sections":[],"primaryContentSections":[{"content":[{"anchor":"discussion","text":"Discussion","level":2,"type":"heading"},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"code":"415","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"200","type":"codeVoice"},{"type":"text","text":": Retrieve detailed metadata for a specific package release"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"400"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"404","type":"codeVoice"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"401"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"429"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]}]}],"kind":"content"}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"},"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}],"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_"]]},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/404":{"abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","title":"404 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"title":"401 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put.json b/docs/data/documentation/registryapi/__scope___name___version_/put.json new file mode 100644 index 00000000..5e1628ea --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put.json @@ -0,0 +1 @@ +{"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_"]]},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","interfaceLanguage":"openapi"},"metadata":{"externalID":"operation:put:\/{scope}\/{name}\/{version}","roleHeading":"HTTP PUT","fragments":[{"kind":"text","text":"PUT"}],"modules":[{"name":"Registry API"}],"role":"symbol","navigatorTitle":[{"text":"PUT \/{scope}\/{name}\/{version}","kind":"text"}],"title":"Create a package release","symbolKind":"method"},"schemaVersion":{"patch":0,"minor":3,"major":0},"primaryContentSections":[{"kind":"content","content":[{"anchor":"discussion","type":"heading","level":2,"text":"Discussion"},{"items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"X-Swift-Package-Signature-Format"},{"text":" (header, Optional):","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"Prefer","type":"codeVoice"},{"type":"text","text":" (header, Optional):"}]}]}],"type":"unorderedList"},{"inlineContent":[{"inlineContent":[{"text":"Request Body:","type":"text"}],"type":"strong"},{"text":" ","type":"text"},{"text":"Content Type: ","type":"text"},{"code":"multipart\/form-data","type":"codeVoice"}],"type":"paragraph"},{"inlineContent":[{"type":"strong","inlineContent":[{"text":"Responses:","type":"text"}]}],"type":"paragraph"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"code":"422","type":"codeVoice"},{"text":": Unprocessable entity - refused to publish the release.","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"429"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"409"},{"type":"text","text":": Conflict - an existing release already exists, or the release is still processing."}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"202"},{"type":"text","text":": The request to publish the package has been accepted and is being processed"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"201","type":"codeVoice"},{"text":": The package release has been successfully published","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"405"},{"type":"text","text":": Method not allowed - publishing is not supported on this server."}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"415","type":"codeVoice"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"401"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"400","type":"codeVoice"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"413","type":"codeVoice"},{"type":"text","text":": Content too large."}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"404"},{"type":"text","text":": Referenced response"}]}]}],"type":"unorderedList"}]}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/put"]}],"sections":[],"abstract":[{"inlineContent":[{"type":"text","text":"Parameters:"}],"type":"strong"}],"topicSections":[{"anchor":"Structures","generated":true,"title":"Structures","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/201","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/202","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/405","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/409","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/413","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/422"]},{"anchor":"Instance-Properties","generated":true,"title":"Instance Properties","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/Prefer","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/X-Swift-Package-Signature-Format"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/405":{"role":"symbol","type":"topic","title":"405 Response","abstract":[{"text":"Method not allowed - publishing is not supported on this server.","type":"text"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"405 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/405","required":true,"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/405"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/413":{"abstract":[{"type":"text","text":"Content too large."}],"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/413","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/413","title":"413 Response","role":"symbol","type":"topic","navigatorTitle":[{"text":"413 Response","kind":"text"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/X-Swift-Package-Signature-Format":{"type":"topic","title":"X-Swift-Package-Signature-Format","role":"symbol","navigatorTitle":[{"kind":"text","text":"X-Swift-Package-Signature-Format"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/X-Swift-Package-Signature-Format","abstract":[],"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/x-swift-package-signature-format","kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/Prefer":{"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/prefer","navigatorTitle":[{"text":"Prefer","kind":"text"}],"type":"topic","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/Prefer","role":"symbol","abstract":[],"title":"Prefer"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/409":{"title":"409 Response","kind":"symbol","navigatorTitle":[{"kind":"text","text":"409 Response"}],"required":true,"abstract":[{"type":"text","text":"Conflict - an existing release already exists, or the release is still processing."}],"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/409","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/409","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/422":{"abstract":[{"text":"Unprocessable entity - refused to publish the release.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/422","title":"422 Response","role":"symbol","navigatorTitle":[{"kind":"text","text":"422 Response"}],"type":"topic","required":true,"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/422"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/201":{"navigatorTitle":[{"kind":"text","text":"201 Response"}],"required":true,"type":"topic","kind":"symbol","abstract":[{"text":"The package release has been successfully published","type":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/201","title":"201 Response","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/201"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/202":{"abstract":[{"text":"The request to publish the package has been accepted and is being processed","type":"text"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/202","title":"202 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/202","role":"symbol","navigatorTitle":[{"kind":"text","text":"202 Response"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/201.json b/docs/data/documentation/registryapi/__scope___name___version_/put/201.json new file mode 100644 index 00000000..ea1af5ee --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/201.json @@ -0,0 +1 @@ +{"kind":"symbol","identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/201","interfaceLanguage":"openapi"},"abstract":[{"text":"The package release has been successfully published","type":"text"}],"schemaVersion":{"major":0,"patch":0,"minor":3},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"metadata":{"symbolKind":"struct","externalID":"response:201","required":true,"title":"201 Response","roleHeading":"Response","navigatorTitle":[{"text":"201 Response","kind":"text"}],"role":"symbol","modules":[{"name":"Registry API"}]},"sections":[],"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/201"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/201":{"navigatorTitle":[{"kind":"text","text":"201 Response"}],"required":true,"type":"topic","kind":"symbol","abstract":[{"text":"The package release has been successfully published","type":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/201","title":"201 Response","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/201"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/202.json b/docs/data/documentation/registryapi/__scope___name___version_/put/202.json new file mode 100644 index 00000000..345c1551 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/202.json @@ -0,0 +1 @@ +{"kind":"symbol","identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/202"},"abstract":[{"text":"The request to publish the package has been accepted and is being processed","type":"text"}],"schemaVersion":{"patch":0,"major":0,"minor":3},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"metadata":{"roleHeading":"Response","modules":[{"name":"Registry API"}],"title":"202 Response","symbolKind":"struct","role":"symbol","navigatorTitle":[{"text":"202 Response","kind":"text"}],"externalID":"response:202"},"sections":[],"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/202"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/202":{"abstract":[{"text":"The request to publish the package has been accepted and is being processed","type":"text"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/202","title":"202 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/202","role":"symbol","navigatorTitle":[{"kind":"text","text":"202 Response"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/405.json b/docs/data/documentation/registryapi/__scope___name___version_/put/405.json new file mode 100644 index 00000000..6c63532c --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/405.json @@ -0,0 +1 @@ +{"metadata":{"role":"symbol","externalID":"response:405","title":"405 Response","navigatorTitle":[{"kind":"text","text":"405 Response"}],"symbolKind":"struct","roleHeading":"Response","modules":[{"name":"Registry API"}],"required":true},"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/405"],"traits":[{"interfaceLanguage":"openapi"}]}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/405","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"kind":"symbol","abstract":[{"type":"text","text":"Method not allowed - publishing is not supported on this server."}],"sections":[],"schemaVersion":{"patch":0,"major":0,"minor":3},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/405":{"role":"symbol","type":"topic","title":"405 Response","abstract":[{"text":"Method not allowed - publishing is not supported on this server.","type":"text"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"405 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/405","required":true,"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/405"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/409.json b/docs/data/documentation/registryapi/__scope___name___version_/put/409.json new file mode 100644 index 00000000..28ad0ea1 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/409.json @@ -0,0 +1 @@ +{"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/409","interfaceLanguage":"openapi"},"kind":"symbol","metadata":{"externalID":"response:409","modules":[{"name":"Registry API"}],"title":"409 Response","required":true,"navigatorTitle":[{"text":"409 Response","kind":"text"}],"symbolKind":"struct","roleHeading":"Response","role":"symbol"},"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"abstract":[{"type":"text","text":"Conflict - an existing release already exists, or the release is still processing."}],"schemaVersion":{"patch":0,"major":0,"minor":3},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/409"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/409":{"title":"409 Response","kind":"symbol","navigatorTitle":[{"kind":"text","text":"409 Response"}],"required":true,"abstract":[{"type":"text","text":"Conflict - an existing release already exists, or the release is still processing."}],"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/409","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/409","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/413.json b/docs/data/documentation/registryapi/__scope___name___version_/put/413.json new file mode 100644 index 00000000..233c93f5 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/413.json @@ -0,0 +1 @@ +{"kind":"symbol","variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/413"]}],"abstract":[{"text":"Content too large.","type":"text"}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/413"},"schemaVersion":{"patch":0,"minor":3,"major":0},"metadata":{"title":"413 Response","navigatorTitle":[{"text":"413 Response","kind":"text"}],"role":"symbol","roleHeading":"Response","required":true,"modules":[{"name":"Registry API"}],"symbolKind":"struct","externalID":"response:413"},"sections":[],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/413":{"abstract":[{"type":"text","text":"Content too large."}],"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/413","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/413","title":"413 Response","role":"symbol","type":"topic","navigatorTitle":[{"text":"413 Response","kind":"text"}],"required":true}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/422.json b/docs/data/documentation/registryapi/__scope___name___version_/put/422.json new file mode 100644 index 00000000..e1226311 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/422.json @@ -0,0 +1 @@ +{"metadata":{"externalID":"response:422","title":"422 Response","symbolKind":"struct","required":true,"role":"symbol","roleHeading":"Response","navigatorTitle":[{"text":"422 Response","kind":"text"}],"modules":[{"name":"Registry API"}]},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/422"],"traits":[{"interfaceLanguage":"openapi"}]}],"schemaVersion":{"patch":0,"minor":3,"major":0},"sections":[],"kind":"symbol","identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/422"},"abstract":[{"text":"Unprocessable entity - refused to publish the release.","type":"text"}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/422":{"abstract":[{"text":"Unprocessable entity - refused to publish the release.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/422","title":"422 Response","role":"symbol","navigatorTitle":[{"kind":"text","text":"422 Response"}],"type":"topic","required":true,"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_\/put\/422"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/prefer.json b/docs/data/documentation/registryapi/__scope___name___version_/put/prefer.json new file mode 100644 index 00000000..ce79313c --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/prefer.json @@ -0,0 +1 @@ +{"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/Prefer","interfaceLanguage":"openapi"},"kind":"symbol","sections":[],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/prefer"]}],"metadata":{"title":"Prefer","modules":[{"name":"Registry API"}],"symbolKind":"property","role":"symbol","externalID":"parameter:Prefer","navigatorTitle":[{"kind":"text","text":"Prefer"}],"roleHeading":"Parameter"},"schemaVersion":{"major":0,"minor":3,"patch":0},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/Prefer":{"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/prefer","navigatorTitle":[{"text":"Prefer","kind":"text"}],"type":"topic","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/Prefer","role":"symbol","abstract":[],"title":"Prefer"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format.json b/docs/data/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format.json new file mode 100644 index 00000000..6f565686 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format.json @@ -0,0 +1 @@ +{"kind":"symbol","metadata":{"symbolKind":"property","roleHeading":"Parameter","modules":[{"name":"Registry API"}],"role":"symbol","navigatorTitle":[{"text":"X-Swift-Package-Signature-Format","kind":"text"}],"title":"X-Swift-Package-Signature-Format","externalID":"parameter:X-Swift-Package-Signature-Format"},"sections":[],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version_\/put\/x-swift-package-signature-format"]}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/X-Swift-Package-Signature-Format","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put"]]},"schemaVersion":{"patch":0,"minor":3,"major":0},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put":{"fragments":[{"kind":"text","text":"PUT"}],"url":"\/documentation\/registryapi\/__scope___name___version_\/put","navigatorTitle":[{"kind":"text","text":"PUT \/{scope}\/{name}\/{version}"}],"title":"Create a package release","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/put/X-Swift-Package-Signature-Format":{"type":"topic","title":"X-Swift-Package-Signature-Format","role":"symbol","navigatorTitle":[{"kind":"text","text":"X-Swift-Package-Signature-Format"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/put\/X-Swift-Package-Signature-Format","abstract":[],"url":"\/documentation\/registryapi\/__scope___name___version_\/put\/x-swift-package-signature-format","kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift.json new file mode 100644 index 00000000..119fe7dc --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift.json @@ -0,0 +1 @@ +{"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift"},"metadata":{"roleHeading":"Path","title":"\/{scope}\/{name}\/{version}\/Package.swift","symbolKind":"protocol","role":"symbol","externalID":"path:\/{scope}\/{name}\/{version}\/Package.swift","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}\/Package.swift"}],"modules":[{"name":"Registry API"}]},"topicSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get"],"generated":true,"title":"Instance Methods","anchor":"Instance-Methods"}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift"]}],"kind":"symbol","sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"schemaVersion":{"major":0,"minor":3,"patch":0},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift":{"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version__package.swift","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}\/Package.swift"}],"role":"symbol","title":"\/{scope}\/{name}\/{version}\/Package.swift","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic","url":"\/documentation\/registryapi","title":"Registry API","role":"collection","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get":{"type":"topic","role":"symbol","title":"Fetch manifest for a package release","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Parameters:"}],"type":"strong"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get","fragments":[{"text":"GET","kind":"text"}],"navigatorTitle":[{"text":"GET \/{scope}\/{name}\/{version}\/Package.swift","kind":"text"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get.json new file mode 100644 index 00000000..b5dfafee --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get.json @@ -0,0 +1 @@ +{"metadata":{"symbolKind":"method","role":"symbol","modules":[{"name":"Registry API"}],"externalID":"operation:get:\/{scope}\/{name}\/{version}\/Package.swift","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}\/Package.swift"}],"title":"Fetch manifest for a package release","fragments":[{"text":"GET","kind":"text"}],"roleHeading":"HTTP GET"},"primaryContentSections":[{"kind":"content","content":[{"type":"heading","text":"Discussion","anchor":"discussion","level":2},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"code":"swift-version","type":"codeVoice"},{"type":"text","text":" (query, Optional):"}],"type":"paragraph"}]}]},{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}]},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"200"},{"text":": Retrieve the manifest file for the specified package release","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"404","type":"codeVoice"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"429","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"400"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"303"},{"type":"text","text":": Redirect to the unqualified Package.swift resource."}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"401","type":"codeVoice"},{"text":": Referenced response","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"415","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]}]}]}],"schemaVersion":{"patch":0,"minor":3,"major":0},"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift"]]},"topicSections":[{"anchor":"Structures","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429"],"title":"Structures","generated":true},{"anchor":"Instance-Properties","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/swift-version"],"title":"Instance Properties","generated":true}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get"]}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get","interfaceLanguage":"openapi"},"kind":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Parameters:"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"title":"401 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/303":{"title":"303 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"303 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303","abstract":[{"text":"See other - download from the URL in the Location header.","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/404":{"abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","title":"404 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift":{"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version__package.swift","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}\/Package.swift"}],"role":"symbol","title":"\/{scope}\/{name}\/{version}\/Package.swift","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/swift-version":{"abstract":[],"type":"topic","kind":"symbol","role":"symbol","navigatorTitle":[{"kind":"text","text":"swift-version"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/swift-version","title":"swift-version","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/swift-version"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get":{"title":"Fetch manifest for a package release","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get","kind":"symbol","navigatorTitle":[{"text":"GET \/{scope}\/{name}\/{version}\/Package.swift","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic","fragments":[{"text":"GET","kind":"text"}],"role":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/200.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/200.json new file mode 100644 index 00000000..4624d142 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/200.json @@ -0,0 +1 @@ +{"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"schemaVersion":{"major":0,"minor":3,"patch":0},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200"]}],"kind":"symbol","metadata":{"symbolKind":"struct","navigatorTitle":[{"text":"200 Response","kind":"text"}],"roleHeading":"Response","role":"symbol","externalID":"response:200","modules":[{"name":"Registry API"}],"required":true,"title":"200 Response"},"sections":[],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","interfaceLanguage":"openapi"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/303.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/303.json new file mode 100644 index 00000000..134fbf5e --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/303.json @@ -0,0 +1 @@ +{"abstract":[{"text":"See other - download from the URL in the Location header.","type":"text"}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303"]}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get"]]},"metadata":{"title":"303 Response","navigatorTitle":[{"kind":"text","text":"303 Response"}],"role":"symbol","roleHeading":"Response","symbolKind":"struct","modules":[{"name":"Registry API"}],"externalID":"response:303"},"kind":"symbol","schemaVersion":{"patch":0,"major":0,"minor":3},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","interfaceLanguage":"openapi"},"sections":[],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/303":{"title":"303 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"303 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/303","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303","abstract":[{"text":"See other - download from the URL in the Location header.","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip/get":{"fragments":[{"kind":"text","text":"GET"}],"navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}.zip"}],"kind":"symbol","url":"\/documentation\/registryapi\/__scope___name___version_.zip\/get","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip\/get","title":"Download source archive for a package release","abstract":[{"type":"strong","inlineContent":[{"text":"Responses:","type":"text"}]}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_.zip":{"abstract":[],"type":"topic","role":"symbol","navigatorTitle":[{"text":"\/{scope}\/{name}\/{version}.zip","kind":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version_.zip","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_.zip","title":"\/{scope}\/{name}\/{version}.zip"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/400.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/400.json new file mode 100644 index 00000000..bb11ca8a --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/400.json @@ -0,0 +1 @@ +{"sections":[],"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"abstract":[{"text":"Referenced response","type":"text"}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400"]}],"schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"metadata":{"roleHeading":"Response","externalID":"response:400","modules":[{"name":"Registry API"}],"role":"symbol","title":"400 Response","navigatorTitle":[{"kind":"text","text":"400 Response"}],"symbolKind":"struct"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/401.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/401.json new file mode 100644 index 00000000..453833c7 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/401.json @@ -0,0 +1 @@ +{"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"metadata":{"role":"symbol","roleHeading":"Response","externalID":"response:401","title":"401 Response","modules":[{"name":"Registry API"}],"symbolKind":"struct","navigatorTitle":[{"text":"401 Response","kind":"text"}]},"schemaVersion":{"patch":0,"minor":3,"major":0},"abstract":[{"text":"Referenced response","type":"text"}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","interfaceLanguage":"openapi"},"sections":[],"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"title":"401 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/404.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/404.json new file mode 100644 index 00000000..d1c6342e --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/404.json @@ -0,0 +1 @@ +{"abstract":[{"text":"Referenced response","type":"text"}],"schemaVersion":{"patch":0,"major":0,"minor":3},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404"],"traits":[{"interfaceLanguage":"openapi"}]}],"kind":"symbol","metadata":{"symbolKind":"struct","roleHeading":"Response","modules":[{"name":"Registry API"}],"title":"404 Response","externalID":"response:404","role":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}]},"sections":[],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/404":{"abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","navigatorTitle":[{"kind":"text","text":"404 Response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/404","title":"404 Response","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/415.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/415.json new file mode 100644 index 00000000..0ff7346c --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/415.json @@ -0,0 +1 @@ +{"schemaVersion":{"minor":3,"patch":0,"major":0},"kind":"symbol","sections":[],"metadata":{"externalID":"response:415","title":"415 Response","roleHeading":"Response","symbolKind":"struct","navigatorTitle":[{"kind":"text","text":"415 Response"}],"modules":[{"name":"Registry API"}],"role":"symbol"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"abstract":[{"type":"text","text":"Referenced response"}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415"]}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/429.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/429.json new file mode 100644 index 00000000..ef92eb2e --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/429.json @@ -0,0 +1 @@ +{"kind":"symbol","identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","interfaceLanguage":"openapi"},"sections":[],"schemaVersion":{"major":0,"patch":0,"minor":3},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429"]}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get"]]},"metadata":{"role":"symbol","modules":[{"name":"Registry API"}],"title":"429 Response","symbolKind":"struct","roleHeading":"Response","navigatorTitle":[{"text":"429 Response","kind":"text"}],"externalID":"response:429"},"abstract":[{"type":"text","text":"Referenced response"}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_/get":{"title":"Fetch metadata for a package release","type":"topic","navigatorTitle":[{"kind":"text","text":"GET \/{scope}\/{name}\/{version}"}],"role":"symbol","fragments":[{"kind":"text","text":"GET"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_\/get","url":"\/documentation\/registryapi\/__scope___name___version_\/get","abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version_":{"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version_","abstract":[],"navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}"}],"title":"\/{scope}\/{name}\/{version}","role":"symbol","type":"topic","url":"\/documentation\/registryapi\/__scope___name___version_"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/swift-version.json b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/swift-version.json new file mode 100644 index 00000000..72886cf9 --- /dev/null +++ b/docs/data/documentation/registryapi/__scope___name___version__package.swift/get/swift-version.json @@ -0,0 +1 @@ +{"sections":[],"schemaVersion":{"minor":3,"major":0,"patch":0},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/swift-version"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get"]]},"variants":[{"paths":["\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/swift-version"],"traits":[{"interfaceLanguage":"openapi"}]}],"metadata":{"navigatorTitle":[{"text":"swift-version","kind":"text"}],"modules":[{"name":"Registry API"}],"externalID":"parameter:swift-version","symbolKind":"property","role":"symbol","roleHeading":"Parameter","title":"swift-version"},"kind":"symbol","references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift":{"abstract":[],"type":"topic","kind":"symbol","role":"symbol","navigatorTitle":[{"kind":"text","text":"\/{scope}\/{name}\/{version}\/Package.swift"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift","title":"\/{scope}\/{name}\/{version}\/Package.swift","url":"\/documentation\/registryapi\/__scope___name___version__package.swift"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"type":"topic","url":"\/documentation\/registryapi","kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","role":"collection","abstract":[{"text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages.","type":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/swift-version":{"abstract":[],"type":"topic","kind":"symbol","role":"symbol","navigatorTitle":[{"kind":"text","text":"swift-version"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/swift-version","title":"swift-version","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/swift-version"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get":{"title":"Fetch manifest for a package release","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get","kind":"symbol","navigatorTitle":[{"text":"GET \/{scope}\/{name}\/{version}\/Package.swift","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Parameters:","type":"text"}]}],"type":"topic","fragments":[{"text":"GET","kind":"text"}],"role":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/_identifiers.json b/docs/data/documentation/registryapi/_identifiers.json new file mode 100644 index 00000000..93cfa7ff --- /dev/null +++ b/docs/data/documentation/registryapi/_identifiers.json @@ -0,0 +1 @@ +{"sections":[],"topicSections":[{"anchor":"Instance-Methods","title":"Instance Methods","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers\/get"],"generated":true}],"schemaVersion":{"major":0,"patch":0,"minor":3},"metadata":{"modules":[{"name":"Registry API"}],"role":"symbol","roleHeading":"Path","title":"\/identifiers","externalID":"path:\/identifiers","symbolKind":"protocol","navigatorTitle":[{"text":"\/identifiers","kind":"text"}]},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers","interfaceLanguage":"openapi"},"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"variants":[{"paths":["\/documentation\/registryapi\/_identifiers"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/_identifiers":{"abstract":[],"navigatorTitle":[{"text":"\/identifiers","kind":"text"}],"title":"\/identifiers","url":"\/documentation\/registryapi\/_identifiers","kind":"symbol","type":"topic","role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_identifiers/get":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers\/get","role":"symbol","title":"Lookup package identifiers registered for a URL","kind":"symbol","type":"topic","url":"\/documentation\/registryapi\/_identifiers\/get","fragments":[{"kind":"text","text":"GET"}],"navigatorTitle":[{"kind":"text","text":"GET \/identifiers"}],"abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/_identifiers/get.json b/docs/data/documentation/registryapi/_identifiers/get.json new file mode 100644 index 00000000..397c3d2a --- /dev/null +++ b/docs/data/documentation/registryapi/_identifiers/get.json @@ -0,0 +1 @@ +{"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/_identifiers\/get"]}],"schemaVersion":{"patch":0,"major":0,"minor":3},"metadata":{"title":"Lookup package identifiers registered for a URL","navigatorTitle":[{"text":"GET \/identifiers","kind":"text"}],"role":"symbol","roleHeading":"HTTP GET","fragments":[{"text":"GET","kind":"text"}],"symbolKind":"method","modules":[{"name":"Registry API"}],"externalID":"operation:get:\/identifiers"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers"]]},"primaryContentSections":[{"content":[{"type":"heading","text":"Discussion","level":2,"anchor":"discussion"},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"401"},{"type":"text","text":": Referenced response"}]}]},{"content":[{"inlineContent":[{"code":"429","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"415"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"200","type":"codeVoice"},{"text":": Retrieve a list of package identifiers registered for a specific URL","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"400","type":"codeVoice"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]}]}],"kind":"content"}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers\/get","interfaceLanguage":"openapi"},"sections":[],"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}],"kind":"symbol","topicSections":[{"title":"Structures","generated":true,"anchor":"Structures","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_identifiers":{"abstract":[],"navigatorTitle":[{"text":"\/identifiers","kind":"text"}],"title":"\/identifiers","url":"\/documentation\/registryapi\/_identifiers","kind":"symbol","type":"topic","role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/200":{"title":"200 Response","type":"topic","navigatorTitle":[{"text":"200 Response","kind":"text"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/200","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","required":true,"abstract":[{"text":"Retrieve a list of all available releases for a given package","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/429":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","kind":"symbol","abstract":[{"type":"text","text":"Referenced response"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/429","title":"429 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"429 Response"}],"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/415":{"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","abstract":[{"type":"text","text":"Referenced response"}],"kind":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/415","role":"symbol","navigatorTitle":[{"kind":"text","text":"415 Response"}],"title":"415 Response","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/400":{"navigatorTitle":[{"text":"400 Response","kind":"text"}],"role":"symbol","type":"topic","kind":"symbol","title":"400 Response","abstract":[{"text":"Referenced response","type":"text"}],"url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/400"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/__scope___name___version__Package.swift/get/401":{"title":"401 Response","type":"topic","navigatorTitle":[{"kind":"text","text":"401 Response"}],"role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/__scope___name___version__Package.swift\/get\/401","url":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","abstract":[{"text":"Referenced response","type":"text"}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_identifiers/get":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_identifiers\/get","role":"symbol","title":"Lookup package identifiers registered for a URL","kind":"symbol","type":"topic","url":"\/documentation\/registryapi\/_identifiers\/get","fragments":[{"kind":"text","text":"GET"}],"navigatorTitle":[{"kind":"text","text":"GET \/identifiers"}],"abstract":[{"inlineContent":[{"type":"text","text":"Responses:"}],"type":"strong"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/_login.json b/docs/data/documentation/registryapi/_login.json new file mode 100644 index 00000000..4214b78b --- /dev/null +++ b/docs/data/documentation/registryapi/_login.json @@ -0,0 +1 @@ +{"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/_login"]}],"schemaVersion":{"minor":3,"patch":0,"major":0},"kind":"symbol","metadata":{"role":"symbol","modules":[{"name":"Registry API"}],"externalID":"path:\/login","title":"\/login","roleHeading":"Path","symbolKind":"protocol","navigatorTitle":[{"kind":"text","text":"\/login"}]},"topicSections":[{"anchor":"Instance-Methods","generated":true,"title":"Instance Methods","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post"]}],"sections":[],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","type":"topic","abstract":[],"url":"\/documentation\/registryapi\/_login","title":"\/login","navigatorTitle":[{"kind":"text","text":"\/login"}],"kind":"symbol","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login/post":{"abstract":[{"text":"Log in using either basic or token authentication. Use the ","type":"text"},{"code":"Authorization","type":"codeVoice"},{"text":" header to provide credentials.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post","title":"Log in to the package registry","role":"symbol","navigatorTitle":[{"text":"POST \/login","kind":"text"}],"type":"topic","kind":"symbol","fragments":[{"text":"POST","kind":"text"}],"url":"\/documentation\/registryapi\/_login\/post"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/_login/post.json b/docs/data/documentation/registryapi/_login/post.json new file mode 100644 index 00000000..0c6f4897 --- /dev/null +++ b/docs/data/documentation/registryapi/_login/post.json @@ -0,0 +1 @@ +{"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/_login\/post"]}],"schemaVersion":{"patch":0,"minor":3,"major":0},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login"]]},"primaryContentSections":[{"content":[{"text":"Discussion","anchor":"discussion","type":"heading","level":2},{"type":"paragraph","inlineContent":[{"type":"text","text":"Also use this endpoint to verify authentication credentials before saving them to the local secrets store."}]},{"type":"paragraph","inlineContent":[{"type":"strong","inlineContent":[{"type":"text","text":"Responses:"}]}]},{"items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"429"},{"type":"text","text":": Referenced response"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"501"},{"type":"text","text":": Registry does not support authentication."}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"200","type":"codeVoice"},{"text":": User successfully logged in to the package registry","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"401","type":"codeVoice"},{"text":": Referenced response","type":"text"}],"type":"paragraph"}]}],"type":"unorderedList"}],"kind":"content"}],"sections":[],"topicSections":[{"title":"Structures","anchor":"Structures","generated":true,"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post\/501"]}],"metadata":{"fragments":[{"text":"POST","kind":"text"}],"roleHeading":"HTTP POST","symbolKind":"method","externalID":"operation:post:\/login","modules":[{"name":"Registry API"}],"navigatorTitle":[{"text":"POST \/login","kind":"text"}],"title":"Log in to the package registry","role":"symbol"},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post","interfaceLanguage":"openapi"},"kind":"symbol","abstract":[{"text":"Log in using either basic or token authentication. Use the ","type":"text"},{"code":"Authorization","type":"codeVoice"},{"text":" header to provide credentials.","type":"text"}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","type":"topic","abstract":[],"url":"\/documentation\/registryapi\/_login","title":"\/login","navigatorTitle":[{"kind":"text","text":"\/login"}],"kind":"symbol","role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login/post":{"abstract":[{"text":"Log in using either basic or token authentication. Use the ","type":"text"},{"code":"Authorization","type":"codeVoice"},{"text":" header to provide credentials.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post","title":"Log in to the package registry","role":"symbol","navigatorTitle":[{"text":"POST \/login","kind":"text"}],"type":"topic","kind":"symbol","fragments":[{"text":"POST","kind":"text"}],"url":"\/documentation\/registryapi\/_login\/post"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login/post/501":{"url":"\/documentation\/registryapi\/_login\/post\/501","abstract":[{"type":"text","text":"Registry does not support authentication."}],"type":"topic","navigatorTitle":[{"kind":"text","text":"501 Response"}],"kind":"symbol","title":"501 Response","role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post\/501"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/_login/post/501.json b/docs/data/documentation/registryapi/_login/post/501.json new file mode 100644 index 00000000..c08e5654 --- /dev/null +++ b/docs/data/documentation/registryapi/_login/post/501.json @@ -0,0 +1 @@ +{"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post"]]},"metadata":{"role":"symbol","roleHeading":"Response","symbolKind":"struct","externalID":"response:501","title":"501 Response","navigatorTitle":[{"text":"501 Response","kind":"text"}],"modules":[{"name":"Registry API"}]},"kind":"symbol","sections":[],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/_login\/post\/501"]}],"abstract":[{"type":"text","text":"Registry does not support authentication."}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post\/501","interfaceLanguage":"openapi"},"schemaVersion":{"major":0,"patch":0,"minor":3},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login/post":{"abstract":[{"text":"Log in using either basic or token authentication. Use the ","type":"text"},{"code":"Authorization","type":"codeVoice"},{"text":" header to provide credentials.","type":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post","title":"Log in to the package registry","role":"symbol","navigatorTitle":[{"text":"POST \/login","kind":"text"}],"type":"topic","kind":"symbol","fragments":[{"text":"POST","kind":"text"}],"url":"\/documentation\/registryapi\/_login\/post"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login/post/501":{"url":"\/documentation\/registryapi\/_login\/post\/501","abstract":[{"type":"text","text":"Registry does not support authentication."}],"type":"topic","navigatorTitle":[{"kind":"text","text":"501 Response"}],"kind":"symbol","title":"501 Response","role":"symbol","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login\/post\/501"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/_login":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/_login","type":"topic","abstract":[],"url":"\/documentation\/registryapi\/_login","title":"\/login","navigatorTitle":[{"kind":"text","text":"\/login"}],"kind":"symbol","role":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/identifier.json b/docs/data/documentation/registryapi/identifier.json new file mode 100644 index 00000000..ef04c060 --- /dev/null +++ b/docs/data/documentation/registryapi/identifier.json @@ -0,0 +1 @@ +{"schemaVersion":{"major":0,"patch":0,"minor":3},"metadata":{"title":"Identifier","navigatorTitle":[{"kind":"text","text":"Identifier"}],"role":"symbol","roleHeading":"String","fragments":[{"text":"Schema","kind":"text"}],"symbolKind":"struct","modules":[{"name":"Registry API"}],"externalID":"schema:Identifier"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"seeAlsoSections":[{"anchor":"Data-Models","generated":true,"title":"Data Models","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"]}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier"},"sections":[],"kind":"symbol","variants":[{"paths":["\/documentation\/registryapi\/identifier"],"traits":[{"interfaceLanguage":"openapi"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/identifiers.json b/docs/data/documentation/registryapi/identifiers.json new file mode 100644 index 00000000..035e3ad3 --- /dev/null +++ b/docs/data/documentation/registryapi/identifiers.json @@ -0,0 +1 @@ +{"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/identifiers"]}],"sections":[],"kind":"symbol","abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","interfaceLanguage":"openapi"},"metadata":{"title":"Identifiers","navigatorTitle":[{"text":"Identifiers","kind":"text"}],"role":"symbol","roleHeading":"Object","fragments":[{"kind":"text","text":"Schema"}],"symbolKind":"struct","modules":[{"name":"Registry API"}],"externalID":"schema:Identifiers"},"schemaVersion":{"minor":3,"major":0,"patch":0},"seeAlsoSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"generated":true,"title":"Data Models","anchor":"Data-Models"}],"primaryContentSections":[{"kind":"content","content":[{"text":"Overview","type":"heading","level":2,"anchor":"overview"},{"items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"identifiers"},{"type":"text","text":" (Required):"}],"type":"paragraph"}]}],"type":"unorderedList"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/listedrelease.json b/docs/data/documentation/registryapi/listedrelease.json new file mode 100644 index 00000000..360b86d5 --- /dev/null +++ b/docs/data/documentation/registryapi/listedrelease.json @@ -0,0 +1 @@ +{"schemaVersion":{"minor":3,"patch":0,"major":0},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/listedrelease"]}],"metadata":{"modules":[{"name":"Registry API"}],"symbolKind":"struct","fragments":[{"text":"Schema","kind":"text"}],"roleHeading":"Object","navigatorTitle":[{"text":"ListedRelease","kind":"text"}],"title":"ListedRelease","required":true,"role":"symbol","externalID":"schema:ListedRelease"},"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"primaryContentSections":[{"kind":"content","content":[{"anchor":"overview","level":2,"text":"Overview","type":"heading"},{"items":[{"content":[{"inlineContent":[{"code":"problem","type":"codeVoice"},{"text":" (Optional):","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"url"},{"text":" (Optional):","type":"text"}]}]}],"type":"unorderedList"}]}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ListedRelease"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"sections":[],"kind":"symbol","references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ListedRelease":{"navigatorTitle":[{"text":"ListedRelease","kind":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ListedRelease","type":"topic","required":true,"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"role":"symbol","title":"ListedRelease","fragments":[{"text":"Schema","kind":"text"}],"url":"\/documentation\/registryapi\/listedrelease","kind":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/packageauthor.json b/docs/data/documentation/registryapi/packageauthor.json new file mode 100644 index 00000000..a9870153 --- /dev/null +++ b/docs/data/documentation/registryapi/packageauthor.json @@ -0,0 +1 @@ +{"primaryContentSections":[{"kind":"content","content":[{"text":"Overview","level":2,"anchor":"overview","type":"heading"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"name"},{"type":"text","text":" (Required):"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"organization"},{"text":" (Optional):","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"url"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"description"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"email","type":"codeVoice"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]}],"type":"unorderedList"}]}],"seeAlsoSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization"],"generated":true,"anchor":"Author-Information","title":"Author Information"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"schemaVersion":{"minor":3,"major":0,"patch":0},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor","interfaceLanguage":"openapi"},"kind":"symbol","sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"variants":[{"paths":["\/documentation\/registryapi\/packageauthor"],"traits":[{"interfaceLanguage":"openapi"}]}],"metadata":{"fragments":[{"kind":"text","text":"Schema"}],"modules":[{"name":"Registry API"}],"role":"symbol","externalID":"schema:PackageAuthor","symbolKind":"struct","title":"PackageAuthor","navigatorTitle":[{"kind":"text","text":"PackageAuthor"}],"roleHeading":"Object","required":true},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageOrganization":{"title":"PackageOrganization","type":"topic","navigatorTitle":[{"kind":"text","text":"PackageOrganization"}],"role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization","url":"\/documentation\/registryapi\/packageorganization","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageAuthor":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"url":"\/documentation\/registryapi\/packageauthor","title":"PackageAuthor","kind":"symbol","navigatorTitle":[{"text":"PackageAuthor","kind":"text"}],"type":"topic","required":true,"role":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/packagemetadata.json b/docs/data/documentation/registryapi/packagemetadata.json new file mode 100644 index 00000000..dea8d9ec --- /dev/null +++ b/docs/data/documentation/registryapi/packagemetadata.json @@ -0,0 +1 @@ +{"sections":[],"metadata":{"title":"PackageMetadata","roleHeading":"Object","role":"symbol","externalID":"schema:PackageMetadata","navigatorTitle":[{"kind":"text","text":"PackageMetadata"}],"modules":[{"name":"Registry API"}],"symbolKind":"struct","required":true,"fragments":[{"kind":"text","text":"Schema"}]},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","interfaceLanguage":"openapi"},"schemaVersion":{"minor":3,"major":0,"patch":0},"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/packagemetadata"]}],"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"topicSections":[{"title":"Author Information","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization"],"anchor":"Author-Information"},{"title":"Package Versions","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ListedRelease"],"anchor":"Package-Versions"}],"seeAlsoSections":[{"title":"Related Documentation","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ListedRelease"],"anchor":"Related-Documentation"},{"generated":true,"title":"Data Models","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"anchor":"Data-Models"}],"primaryContentSections":[{"kind":"content","content":[{"text":"Overview","type":"heading","level":2,"anchor":"overview"},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"repositoryURLs"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"author","type":"codeVoice"},{"text":" (Optional):","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"description"},{"text":" (Optional):","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"readmeURL"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"originalPublicationTime","type":"codeVoice"},{"text":" (Optional):","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"licenseURL"},{"type":"text","text":" (Optional):"}]}]}]},{"inlineContent":[{"type":"text","text":"A comprehensive representation of metadata for a Swift package."}],"type":"paragraph"},{"text":"Overview","type":"heading","level":2,"anchor":"Overview"},{"inlineContent":[{"type":"text","text":"The "},{"type":"codeVoice","code":"PackageMetadata"},{"type":"text","text":" structure contains all descriptive information about a Swift package, including details about the package’s author, license, and available versions."}],"type":"paragraph"},{"type":"codeListing","syntax":"swift","code":["\/\/ Example: Fetching and using package metadata","let url = URL(string: \"https:\/\/registry.example.com\/mona\/LinkedList\")!","let (data, _) = try await URLSession.shared.data(from: url)","let metadata = try JSONDecoder().decode(PackageMetadata.self, from: data)","","\/\/ Use metadata properties","print(\"Package name: \\(metadata.name)\")","print(\"Latest version: \\(metadata.latestVersion)\")","print(\"Available versions: \\(metadata.versions.joined(separator: \", \"))\")"]},{"type":"paragraph","inlineContent":[{"type":"text","text":"Package metadata provides a complete picture of a package, including:"}]},{"items":[{"content":[{"inlineContent":[{"type":"text","text":"Basic information like name, version, and description"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"text":"Author and organization information","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"text":"License details","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"text":"Repository location","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"type":"text","text":"Available versions"}],"type":"paragraph"}]}],"type":"unorderedList"}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageAuthor":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"url":"\/documentation\/registryapi\/packageauthor","title":"PackageAuthor","kind":"symbol","navigatorTitle":[{"text":"PackageAuthor","kind":"text"}],"type":"topic","required":true,"role":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ListedRelease":{"navigatorTitle":[{"text":"ListedRelease","kind":"text"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ListedRelease","type":"topic","required":true,"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"role":"symbol","title":"ListedRelease","fragments":[{"text":"Schema","kind":"text"}],"url":"\/documentation\/registryapi\/listedrelease","kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageOrganization":{"title":"PackageOrganization","type":"topic","navigatorTitle":[{"kind":"text","text":"PackageOrganization"}],"role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization","url":"\/documentation\/registryapi\/packageorganization","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/packageorganization.json b/docs/data/documentation/registryapi/packageorganization.json new file mode 100644 index 00000000..5f50640c --- /dev/null +++ b/docs/data/documentation/registryapi/packageorganization.json @@ -0,0 +1 @@ +{"variants":[{"paths":["\/documentation\/registryapi\/packageorganization"],"traits":[{"interfaceLanguage":"openapi"}]}],"schemaVersion":{"minor":3,"major":0,"patch":0},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"kind":"symbol","sections":[],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"seeAlsoSections":[{"title":"Author Information","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor"],"generated":true,"anchor":"Author-Information"}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization","interfaceLanguage":"openapi"},"metadata":{"roleHeading":"Object","navigatorTitle":[{"kind":"text","text":"PackageOrganization"}],"symbolKind":"struct","fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"PackageOrganization","externalID":"schema:PackageOrganization","modules":[{"name":"Registry API"}]},"primaryContentSections":[{"kind":"content","content":[{"text":"Overview","type":"heading","level":2,"anchor":"overview"},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"description"},{"type":"text","text":" (Optional):"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"name"},{"text":" (Required):","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"email","type":"codeVoice"},{"text":" (Optional):","type":"text"}],"type":"paragraph"}]},{"content":[{"inlineContent":[{"code":"url","type":"codeVoice"},{"text":" (Optional):","type":"text"}],"type":"paragraph"}]}]}]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageOrganization":{"title":"PackageOrganization","type":"topic","navigatorTitle":[{"kind":"text","text":"PackageOrganization"}],"role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageOrganization","url":"\/documentation\/registryapi\/packageorganization","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageAuthor":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageAuthor","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"url":"\/documentation\/registryapi\/packageauthor","title":"PackageAuthor","kind":"symbol","navigatorTitle":[{"text":"PackageAuthor","kind":"text"}],"type":"topic","required":true,"role":"symbol"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/problemdetails.json b/docs/data/documentation/registryapi/problemdetails.json new file mode 100644 index 00000000..1ef57659 --- /dev/null +++ b/docs/data/documentation/registryapi/problemdetails.json @@ -0,0 +1 @@ +{"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"schemaVersion":{"patch":0,"major":0,"minor":3},"seeAlsoSections":[{"title":"Data Models","generated":true,"anchor":"Data-Models","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"]}],"metadata":{"externalID":"schema:ProblemDetails","modules":[{"name":"Registry API"}],"roleHeading":"Object","symbolKind":"struct","role":"symbol","title":"ProblemDetails","navigatorTitle":[{"kind":"text","text":"ProblemDetails"}],"fragments":[{"text":"Schema","kind":"text"}]},"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails"},"kind":"symbol","variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/problemdetails"]}],"primaryContentSections":[{"kind":"content","content":[{"type":"heading","anchor":"overview","text":"Overview","level":2},{"type":"unorderedList","items":[{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"type"},{"type":"text","text":" (Optional):"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"status"},{"text":" (Optional):","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"detail"},{"type":"text","text":" (Optional):"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"title"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"instance"},{"type":"text","text":" (Optional):"}]}]}]}]}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"sections":[],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/publishresponse.json b/docs/data/documentation/registryapi/publishresponse.json new file mode 100644 index 00000000..136f1681 --- /dev/null +++ b/docs/data/documentation/registryapi/publishresponse.json @@ -0,0 +1 @@ +{"sections":[],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"metadata":{"role":"symbol","roleHeading":"Object","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"externalID":"schema:PublishResponse","modules":[{"name":"Registry API"}],"title":"PublishResponse","symbolKind":"struct"},"primaryContentSections":[{"content":[{"type":"heading","level":2,"text":"Overview","anchor":"overview"},{"type":"unorderedList","items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"message"},{"text":" (Optional):","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"url","type":"codeVoice"},{"type":"text","text":" (Optional):"}]}]}]}],"kind":"content"}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"schemaVersion":{"patch":0,"major":0,"minor":3},"kind":"symbol","seeAlsoSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature"],"title":"Data Models","generated":true,"anchor":"Data-Models"}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/publishresponse"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/registryapi.json b/docs/data/documentation/registryapi/registryapi.json new file mode 100644 index 00000000..84d67b46 --- /dev/null +++ b/docs/data/documentation/registryapi/registryapi.json @@ -0,0 +1 @@ +{"kind":"symbol","hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"metadata":{"modules":[{"name":"Registry API"}],"roleHeading":"Module","role":"collection","navigatorTitle":[{"kind":"text","text":"RegistryAPI"}],"symbolKind":"module","externalID":"module","title":"RegistryAPI"},"schemaVersion":{"minor":3,"patch":0,"major":0},"abstract":[{"type":"text","text":"API for managing Swift package releases and interacting with the package registry."}],"sections":[],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/registryapi"]}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/RegistryAPI"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/RegistryAPI":{"abstract":[{"text":"API for managing Swift package releases and interacting with the package registry.","type":"text"}],"navigatorTitle":[{"kind":"text","text":"RegistryAPI"}],"role":"collection","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/RegistryAPI","type":"topic","title":"RegistryAPI","kind":"symbol","url":"\/documentation\/registryapi\/registryapi"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/releasemetadata.json b/docs/data/documentation/registryapi/releasemetadata.json new file mode 100644 index 00000000..8a682151 --- /dev/null +++ b/docs/data/documentation/registryapi/releasemetadata.json @@ -0,0 +1 @@ +{"kind":"symbol","sections":[],"primaryContentSections":[{"kind":"content","content":[{"type":"heading","level":2,"anchor":"overview","text":"Overview"},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"code":"version","type":"codeVoice"},{"type":"text","text":" (Required):"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"metadata","type":"codeVoice"},{"text":" (Required):","type":"text"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"type":"codeVoice","code":"id"},{"type":"text","text":" (Required):"}]}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"resources","type":"codeVoice"},{"type":"text","text":" (Required):"}]}]},{"content":[{"inlineContent":[{"code":"publishedAt","type":"codeVoice"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]}],"type":"unorderedList"}]}],"identifier":{"interfaceLanguage":"openapi","url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"schemaVersion":{"patch":0,"major":0,"minor":3},"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"metadata":{"required":true,"roleHeading":"Object","title":"ReleaseMetadata","externalID":"schema:ReleaseMetadata","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"symbolKind":"struct","navigatorTitle":[{"text":"ReleaseMetadata","kind":"text"}],"modules":[{"name":"Registry API"}]},"seeAlsoSections":[{"title":"Data Models","identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"anchor":"Data-Models","generated":true}],"variants":[{"traits":[{"interfaceLanguage":"openapi"}],"paths":["\/documentation\/registryapi\/releasemetadata"]}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/releaseresource.json b/docs/data/documentation/registryapi/releaseresource.json new file mode 100644 index 00000000..4b4a0c2f --- /dev/null +++ b/docs/data/documentation/registryapi/releaseresource.json @@ -0,0 +1 @@ +{"seeAlsoSections":[{"generated":true,"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"anchor":"Data-Models","title":"Data Models"}],"variants":[{"paths":["\/documentation\/registryapi\/releaseresource"],"traits":[{"interfaceLanguage":"openapi"}]}],"kind":"symbol","schemaVersion":{"major":0,"minor":3,"patch":0},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","interfaceLanguage":"openapi"},"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"primaryContentSections":[{"content":[{"anchor":"overview","text":"Overview","type":"heading","level":2},{"items":[{"content":[{"type":"paragraph","inlineContent":[{"code":"name","type":"codeVoice"},{"text":" (Required):","type":"text"}]}]},{"content":[{"inlineContent":[{"type":"codeVoice","code":"checksum"},{"type":"text","text":" (Required):"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"type","type":"codeVoice"},{"text":" (Required):","type":"text"}]}]},{"content":[{"inlineContent":[{"code":"signing","type":"codeVoice"},{"type":"text","text":" (Optional):"}],"type":"paragraph"}]}],"type":"unorderedList"}],"kind":"content"}],"metadata":{"required":true,"title":"ReleaseResource","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"symbolKind":"struct","roleHeading":"Object","externalID":"schema:ReleaseResource","modules":[{"name":"Registry API"}],"navigatorTitle":[{"text":"ReleaseResource","kind":"text"}]},"sections":[],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/releases.json b/docs/data/documentation/registryapi/releases.json new file mode 100644 index 00000000..1a9f321e --- /dev/null +++ b/docs/data/documentation/registryapi/releases.json @@ -0,0 +1 @@ +{"primaryContentSections":[{"content":[{"level":2,"type":"heading","text":"Overview","anchor":"overview"},{"items":[{"content":[{"inlineContent":[{"type":"codeVoice","code":"releases"},{"type":"text","text":" (Required):"}],"type":"paragraph"}]}],"type":"unorderedList"}],"kind":"content"}],"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","interfaceLanguage":"openapi"},"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"variants":[{"paths":["\/documentation\/registryapi\/releases"],"traits":[{"interfaceLanguage":"openapi"}]}],"seeAlsoSections":[{"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"],"title":"Data Models","generated":true,"anchor":"Data-Models"}],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"sections":[],"kind":"symbol","schemaVersion":{"major":0,"patch":0,"minor":3},"metadata":{"fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"text":"Releases","kind":"text"}],"role":"symbol","modules":[{"name":"Registry API"}],"title":"Releases","externalID":"schema:Releases","symbolKind":"struct","roleHeading":"Object"},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/data/documentation/registryapi/releasesignature.json b/docs/data/documentation/registryapi/releasesignature.json new file mode 100644 index 00000000..f2c2dd91 --- /dev/null +++ b/docs/data/documentation/registryapi/releasesignature.json @@ -0,0 +1 @@ +{"primaryContentSections":[{"kind":"content","content":[{"level":2,"text":"Overview","type":"heading","anchor":"overview"},{"items":[{"content":[{"inlineContent":[{"code":"signatureFormat","type":"codeVoice"},{"text":" (Required):","type":"text"}],"type":"paragraph"}]},{"content":[{"type":"paragraph","inlineContent":[{"code":"signatureBase64Encoded","type":"codeVoice"},{"text":" (Required):","type":"text"}]}]}],"type":"unorderedList"}]}],"sections":[],"hierarchy":{"paths":[["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI"]]},"variants":[{"paths":["\/documentation\/registryapi\/releasesignature"],"traits":[{"interfaceLanguage":"openapi"}]}],"kind":"symbol","metadata":{"role":"symbol","modules":[{"name":"Registry API"}],"roleHeading":"Object","externalID":"schema:ReleaseSignature","fragments":[{"text":"Schema","kind":"text"}],"symbolKind":"struct","navigatorTitle":[{"kind":"text","text":"ReleaseSignature"}],"title":"ReleaseSignature"},"identifier":{"url":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","interfaceLanguage":"openapi"},"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"seeAlsoSections":[{"title":"Data Models","anchor":"Data-Models","generated":true,"identifiers":["doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"]}],"schemaVersion":{"major":0,"patch":0,"minor":3},"references":{"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseMetadata":{"abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"type":"topic","required":true,"role":"symbol","kind":"symbol","title":"ReleaseMetadata","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseMetadata","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"ReleaseMetadata"}],"url":"\/documentation\/registryapi\/releasemetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseResource":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseResource","title":"ReleaseResource","fragments":[{"kind":"text","text":"Schema"}],"role":"symbol","url":"\/documentation\/registryapi\/releaseresource","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"kind":"symbol","type":"topic","navigatorTitle":[{"kind":"text","text":"ReleaseResource"}],"required":true},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PackageMetadata":{"required":true,"navigatorTitle":[{"text":"PackageMetadata","kind":"text"}],"abstract":[{"inlineContent":[{"text":"Properties:","type":"text"}],"type":"strong"}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PackageMetadata","url":"\/documentation\/registryapi\/packagemetadata","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PackageMetadata"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/PublishResponse":{"navigatorTitle":[{"text":"PublishResponse","kind":"text"}],"abstract":[{"type":"strong","inlineContent":[{"text":"Properties:","type":"text"}]}],"kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"title":"PublishResponse","url":"\/documentation\/registryapi\/publishresponse","role":"symbol","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/PublishResponse"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Releases":{"url":"\/documentation\/registryapi\/releases","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Releases","role":"symbol","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"title":"Releases","kind":"symbol","fragments":[{"text":"Schema","kind":"text"}],"navigatorTitle":[{"text":"Releases","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifier":{"navigatorTitle":[{"text":"Identifier","kind":"text"}],"title":"Identifier","type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifier","kind":"symbol","role":"symbol","fragments":[{"kind":"text","text":"Schema"}],"abstract":[],"url":"\/documentation\/registryapi\/identifier"},"doc://com.example.RegistryAPI/documentation/RegistryAPI/Identifiers":{"type":"topic","abstract":[{"type":"strong","inlineContent":[{"type":"text","text":"Properties:"}]}],"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/Identifiers","title":"Identifiers","role":"symbol","url":"\/documentation\/registryapi\/identifiers","kind":"symbol","fragments":[{"kind":"text","text":"Schema"}],"navigatorTitle":[{"kind":"text","text":"Identifiers"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ReleaseSignature":{"type":"topic","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ReleaseSignature","url":"\/documentation\/registryapi\/releasesignature","kind":"symbol","abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"fragments":[{"text":"Schema","kind":"text"}],"role":"symbol","title":"ReleaseSignature","navigatorTitle":[{"text":"ReleaseSignature","kind":"text"}]},"doc://com.example.RegistryAPI/documentation/RegistryAPI/ProblemDetails":{"identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI\/ProblemDetails","kind":"symbol","url":"\/documentation\/registryapi\/problemdetails","role":"symbol","fragments":[{"text":"Schema","kind":"text"}],"abstract":[{"inlineContent":[{"type":"text","text":"Properties:"}],"type":"strong"}],"navigatorTitle":[{"text":"ProblemDetails","kind":"text"}],"title":"ProblemDetails","type":"topic"},"doc://com.example.RegistryAPI/documentation/RegistryAPI":{"url":"\/documentation\/registryapi","identifier":"doc:\/\/com.example.RegistryAPI\/documentation\/RegistryAPI","title":"Registry API","kind":"symbol","role":"collection","abstract":[{"type":"text","text":"Interact with Swift packages through a standardized API for publishing, discovering, and retrieving packages."}],"type":"topic"}}} \ No newline at end of file diff --git a/docs/documentation/registry-api/authentication/index.html b/docs/documentation/registry-api/authentication/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/authentication/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/errorcodes/index.html b/docs/documentation/registry-api/errorcodes/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/errorcodes/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/gettingstarted/index.html b/docs/documentation/registry-api/gettingstarted/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/gettingstarted/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/performance/index.html b/docs/documentation/registry-api/performance/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/performance/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/publishing/index.html b/docs/documentation/registry-api/publishing/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/publishing/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/ratelimiting/index.html b/docs/documentation/registry-api/ratelimiting/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/ratelimiting/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registry-api/security/index.html b/docs/documentation/registry-api/security/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registry-api/security/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name_/get/index.html b/docs/documentation/registryapi/__scope___name_/get/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name_/get/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name_/index.html b/docs/documentation/registryapi/__scope___name_/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name_/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_.zip/get/index.html b/docs/documentation/registryapi/__scope___name___version_.zip/get/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_.zip/get/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_.zip/index.html b/docs/documentation/registryapi/__scope___name___version_.zip/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_.zip/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/get/index.html b/docs/documentation/registryapi/__scope___name___version_/get/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/get/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/index.html b/docs/documentation/registryapi/__scope___name___version_/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/201/index.html b/docs/documentation/registryapi/__scope___name___version_/put/201/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/201/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/202/index.html b/docs/documentation/registryapi/__scope___name___version_/put/202/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/202/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/405/index.html b/docs/documentation/registryapi/__scope___name___version_/put/405/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/405/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/409/index.html b/docs/documentation/registryapi/__scope___name___version_/put/409/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/409/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/413/index.html b/docs/documentation/registryapi/__scope___name___version_/put/413/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/413/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/422/index.html b/docs/documentation/registryapi/__scope___name___version_/put/422/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/422/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/index.html b/docs/documentation/registryapi/__scope___name___version_/put/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/prefer/index.html b/docs/documentation/registryapi/__scope___name___version_/put/prefer/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/prefer/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format/index.html b/docs/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version_/put/x-swift-package-signature-format/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/200/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/200/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/200/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/303/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/303/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/303/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/400/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/400/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/400/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/401/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/401/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/401/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/404/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/404/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/404/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/415/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/415/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/415/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/429/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/429/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/429/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/get/swift-version/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/get/swift-version/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/get/swift-version/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/__scope___name___version__package.swift/index.html b/docs/documentation/registryapi/__scope___name___version__package.swift/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/__scope___name___version__package.swift/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/_identifiers/get/index.html b/docs/documentation/registryapi/_identifiers/get/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/_identifiers/get/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/_identifiers/index.html b/docs/documentation/registryapi/_identifiers/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/_identifiers/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/_login/index.html b/docs/documentation/registryapi/_login/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/_login/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/_login/post/501/index.html b/docs/documentation/registryapi/_login/post/501/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/_login/post/501/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/_login/post/index.html b/docs/documentation/registryapi/_login/post/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/_login/post/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/identifier/index.html b/docs/documentation/registryapi/identifier/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/identifier/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/identifiers/index.html b/docs/documentation/registryapi/identifiers/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/identifiers/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/index.html b/docs/documentation/registryapi/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/listedrelease/index.html b/docs/documentation/registryapi/listedrelease/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/listedrelease/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/packageauthor/index.html b/docs/documentation/registryapi/packageauthor/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/packageauthor/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/packagemetadata/index.html b/docs/documentation/registryapi/packagemetadata/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/packagemetadata/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/packageorganization/index.html b/docs/documentation/registryapi/packageorganization/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/packageorganization/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/problemdetails/index.html b/docs/documentation/registryapi/problemdetails/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/problemdetails/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/publishresponse/index.html b/docs/documentation/registryapi/publishresponse/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/publishresponse/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/registryapi/index.html b/docs/documentation/registryapi/registryapi/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/registryapi/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/releasemetadata/index.html b/docs/documentation/registryapi/releasemetadata/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/releasemetadata/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/releaseresource/index.html b/docs/documentation/registryapi/releaseresource/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/releaseresource/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/releases/index.html b/docs/documentation/registryapi/releases/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/releases/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/documentation/registryapi/releasesignature/index.html b/docs/documentation/registryapi/releasesignature/index.html new file mode 100644 index 00000000..a41f910e --- /dev/null +++ b/docs/documentation/registryapi/releasesignature/index.html @@ -0,0 +1 @@ +Documentation
\ No newline at end of file diff --git a/docs/images/com.example.RegistryAPI/performance_diagram.svg b/docs/images/com.example.RegistryAPI/performance_diagram.svg new file mode 100644 index 00000000..2a45de32 --- /dev/null +++ b/docs/images/com.example.RegistryAPI/performance_diagram.svg @@ -0,0 +1,98 @@ + + + + + + + Performance Optimization Techniques + + + + Client Application + + + + Memory Cache + Fast in-memory storage + + + + Disk Cache + Persistent storage + + + + Request Manager + Deduplication & Batching + + + + Prefetching + Anticipate future needs + + + + Registry Server + + + + API Endpoints + Package resources + + + + Rate Limiting + Throttles requests + + + + Conditional Responses + ETags & 304 Not Modified + + + + Compression + Reduces payload size + + + + Network Optimizations + + + â€ĸ Connection Pooling + â€ĸ Parallel Requests + â€ĸ Prioritization + â€ĸ Retry with Backoff + + + + + Cache Hit + + + + + + + + + + + If-None-Match: "etag" + + + + + 304 Not Modified + + + + + Compressed Response + + + + + Client respects limits + + diff --git a/docs/images/com.example.RegistryAPI/registry_workflow.svg b/docs/images/com.example.RegistryAPI/registry_workflow.svg new file mode 100644 index 00000000..41a59145 --- /dev/null +++ b/docs/images/com.example.RegistryAPI/registry_workflow.svg @@ -0,0 +1,69 @@ + + + + + + + Swift Package Registry Workflow + + + + Discover + + + + 🔍 + Search + + + 📋 + Browse + + + ℹī¸ + Get Info + + + + Retrieve + + + + đŸ“Ļ + Download + + + 📄 + Manifest + + + đŸ”ĸ + Versions + + + + Publish + + + + 🔐 + Authenticate + + + âŦ†ī¸ + Upload + + + 🔄 + Update + + + + + + + + + + Registry API enables seamless package discovery, retrieval, and publishing + diff --git a/docs/index.html b/docs/index.html index 87a511bf..e56f1f0f 100644 --- a/docs/index.html +++ b/docs/index.html @@ -1 +1,11 @@ -Documentation
+ + + + + + Redirecting to API Documentation + + +

If you are not redirected automatically, click here.

+ + diff --git a/docs/index/index.json b/docs/index/index.json index 18e59642..0e0bb8f3 100644 --- a/docs/index/index.json +++ b/docs/index/index.json @@ -1 +1 @@ -{"includedArchiveIdentifiers":["com.example.YourAPI"],"interfaceLanguages":{},"schemaVersion":{"major":0,"minor":1,"patch":2}} \ No newline at end of file +{"includedArchiveIdentifiers":["com.example.RegistryAPI"],"interfaceLanguages":{"openapi":[{"children":[{"title":"API Endpoints","type":"groupMarker"},{"path":"\/documentation\/registry-api\/gettingstarted","title":"Getting Started with Swift Package Registry","type":"article"},{"title":"Data Models","type":"groupMarker"},{"children":[{"title":"Author Information","type":"groupMarker"},{"path":"\/documentation\/registryapi\/packageauthor","title":"PackageAuthor","type":"struct"},{"path":"\/documentation\/registryapi\/packageorganization","title":"PackageOrganization","type":"struct"},{"title":"Package Versions","type":"groupMarker"},{"path":"\/documentation\/registryapi\/listedrelease","title":"ListedRelease","type":"struct"}],"path":"\/documentation\/registryapi\/packagemetadata","title":"PackageMetadata","type":"struct"},{"path":"\/documentation\/registryapi\/releaseresource","title":"ReleaseResource","type":"struct"},{"path":"\/documentation\/registryapi\/problemdetails","title":"ProblemDetails","type":"struct"},{"path":"\/documentation\/registryapi\/identifier","title":"Identifier","type":"struct"},{"path":"\/documentation\/registryapi\/identifiers","title":"Identifiers","type":"struct"},{"path":"\/documentation\/registryapi\/releases","title":"Releases","type":"struct"},{"path":"\/documentation\/registryapi\/releasemetadata","title":"ReleaseMetadata","type":"struct"},{"path":"\/documentation\/registryapi\/releasesignature","title":"ReleaseSignature","type":"struct"},{"path":"\/documentation\/registryapi\/publishresponse","title":"PublishResponse","type":"struct"},{"title":"Guides","type":"groupMarker"},{"path":"\/documentation\/registry-api\/authentication","title":"Authentication","type":"article"},{"path":"\/documentation\/registry-api\/publishing","title":"Publishing Packages","type":"article"},{"path":"\/documentation\/registry-api\/errorcodes","title":"Error Codes","type":"article"},{"path":"\/documentation\/registry-api\/ratelimiting","title":"Rate Limiting","type":"article"},{"path":"\/documentation\/registry-api\/security","title":"Security Best Practices","type":"article"},{"path":"\/documentation\/registry-api\/performance","title":"Performance Optimization","type":"article"},{"title":"Protocols","type":"groupMarker"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","title":"200 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","title":"400 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","title":"401 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","title":"404 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","title":"415 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","title":"429 Response","type":"struct"}],"path":"\/documentation\/registryapi\/__scope___name_\/get","title":"GET \/{scope}\/{name}","type":"method"}],"path":"\/documentation\/registryapi\/__scope___name_","title":"\/{scope}\/{name}","type":"protocol"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","title":"200 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","title":"400 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","title":"401 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","title":"404 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","title":"415 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","title":"429 Response","type":"struct"}],"path":"\/documentation\/registryapi\/__scope___name___version_\/get","title":"GET \/{scope}\/{name}\/{version}","type":"method"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/201","title":"201 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/202","title":"202 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/405","title":"405 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/409","title":"409 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/413","title":"413 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/422","title":"422 Response","type":"struct"},{"title":"Instance Properties","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/prefer","title":"Prefer","type":"property"},{"path":"\/documentation\/registryapi\/__scope___name___version_\/put\/x-swift-package-signature-format","title":"X-Swift-Package-Signature-Format","type":"property"}],"path":"\/documentation\/registryapi\/__scope___name___version_\/put","title":"PUT \/{scope}\/{name}\/{version}","type":"method"}],"path":"\/documentation\/registryapi\/__scope___name___version_","title":"\/{scope}\/{name}\/{version}","type":"protocol"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","title":"200 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303","title":"303 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","title":"400 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","title":"401 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","title":"404 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","title":"415 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","title":"429 Response","type":"struct"}],"path":"\/documentation\/registryapi\/__scope___name___version_.zip\/get","title":"GET \/{scope}\/{name}\/{version}.zip","type":"method"}],"path":"\/documentation\/registryapi\/__scope___name___version_.zip","title":"\/{scope}\/{name}\/{version}.zip","type":"protocol"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","title":"200 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/303","title":"303 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","title":"400 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","title":"401 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/404","title":"404 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","title":"415 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","title":"429 Response","type":"struct"},{"title":"Instance Properties","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/swift-version","title":"swift-version","type":"property"}],"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get","title":"GET \/{scope}\/{name}\/{version}\/Package.swift","type":"method"}],"path":"\/documentation\/registryapi\/__scope___name___version__package.swift","title":"\/{scope}\/{name}\/{version}\/Package.swift","type":"protocol"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/200","title":"200 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/400","title":"400 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/401","title":"401 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/415","title":"415 Response","type":"struct"},{"path":"\/documentation\/registryapi\/__scope___name___version__package.swift\/get\/429","title":"429 Response","type":"struct"}],"path":"\/documentation\/registryapi\/_identifiers\/get","title":"GET \/identifiers","type":"method"}],"path":"\/documentation\/registryapi\/_identifiers","title":"\/identifiers","type":"protocol"},{"children":[{"title":"Instance Methods","type":"groupMarker"},{"children":[{"title":"Structures","type":"groupMarker"},{"path":"\/documentation\/registryapi\/_login\/post\/501","title":"501 Response","type":"struct"}],"path":"\/documentation\/registryapi\/_login\/post","title":"POST \/login","type":"method"}],"path":"\/documentation\/registryapi\/_login","title":"\/login","type":"protocol"}],"path":"\/documentation\/registryapi","title":"Registry API","type":"module"},{"path":"\/documentation\/registryapi\/registryapi","title":"RegistryAPI","type":"module"}]},"schemaVersion":{"major":0,"minor":1,"patch":2}} \ No newline at end of file diff --git a/docs/metadata.json b/docs/metadata.json index 273cc12f..59651147 100644 --- a/docs/metadata.json +++ b/docs/metadata.json @@ -1 +1 @@ -{"schemaVersion":{"minor":1,"patch":0,"major":0},"bundleID":"com.example.YourAPI","bundleDisplayName":"YourAPI"} \ No newline at end of file +{"bundleDisplayName":"Registry API","bundleID":"com.example.RegistryAPI","schemaVersion":{"minor":1,"major":0,"patch":0}} \ No newline at end of file diff --git a/scripts/build-docs.sh b/scripts/build-docs.sh index ba4c7d23..d4c57019 100755 --- a/scripts/build-docs.sh +++ b/scripts/build-docs.sh @@ -1,43 +1,50 @@ #!/bin/bash -# Script to generate API documentation +# Script to convert an OpenAPI specification to DocC documentation -# Create output directory if it doesn't exist -mkdir -p docs +# Path to the OpenAPI specification file +OPENAPI_SPEC="registry.openapi.yaml" +# Output directory for the DocC documentation +DOCC_OUTPUT_DIR="docs" +# Symbol graph output directory +SYMBOL_GRAPH_DIR="./symbolgraphs" + +# Create output directories if they don't exist +mkdir -p $DOCC_OUTPUT_DIR +mkdir -p $SYMBOL_GRAPH_DIR -# Convert OpenAPI specification to symbol graph echo "Converting OpenAPI spec to SymbolGraph..." -swift run openapi-to-symbolgraph registry.openapi.yaml --output-path registry.symbolgraph.json --module-name "RegistryAPI" --base-url "https://api.example.com" +# Run the OpenAPI to SymbolGraph converter +swift run openapi-to-symbolgraph $OPENAPI_SPEC --output $SYMBOL_GRAPH_DIR --module-name "RegistryAPI" --base-url "https://api.example.com" -# Generate DocC documentation echo "Generating DocC documentation..." +# Generate DocC documentation xcrun docc convert RegistryAPI.docc \ --fallback-display-name "Registry API" \ --fallback-bundle-identifier com.example.RegistryAPI \ --fallback-bundle-version 1.0.0 \ - --additional-symbol-graph-dir ./ \ - --output-path ./docs + --additional-symbol-graph-dir $SYMBOL_GRAPH_DIR \ + --output-path $DOCC_OUTPUT_DIR # Create a root index.html to redirect to the API docs -cat > docs/index.html << 'EOF' +cat > $DOCC_OUTPUT_DIR/index.html << 'EOF' - + Redirecting to API Documentation -

If you are not redirected automatically, click here.

+

If you are not redirected automatically, click here.

EOF # Fix paths in generated HTML files -chmod +x scripts/fix-paths.sh ./scripts/fix-paths.sh # Make sure .nojekyll file exists -touch docs/.nojekyll +touch $DOCC_OUTPUT_DIR/.nojekyll -echo "Documentation generated successfully in ./docs directory" +echo "Documentation generated successfully in $DOCC_OUTPUT_DIR directory" echo "You can preview it using: ./scripts/local-preview.sh" diff --git a/swift-docc-symbolkit b/swift-docc-symbolkit new file mode 160000 index 00000000..ddacb655 --- /dev/null +++ b/swift-docc-symbolkit @@ -0,0 +1 @@ +Subproject commit ddacb655e2087fd722cb5ca2bcc49953ee267e37 diff --git a/symbolgraphs/RegistryAPI.symbols.json b/symbolgraphs/RegistryAPI.symbols.json new file mode 100644 index 00000000..0b4cc743 --- /dev/null +++ b/symbolgraphs/RegistryAPI.symbols.json @@ -0,0 +1,2212 @@ +{ + "metadata" : { + "formatVersion" : { + "major" : 0, + "minor" : 5, + "patch" : 3 + }, + "generator" : "OpenAPItoSymbolGraph" + }, + "module" : { + "isVirtual" : false, + "name" : "RegistryAPI", + "platform" : { + "vendor" : "OpenAPI" + } + }, + "relationships" : [ + { + "kind" : "memberOf", + "source" : "path:\/{scope}\/{name}", + "target" : "module", + "targetFallback" : "\/{scope}\/{name}" + }, + { + "kind" : "memberOf", + "source" : "operation:get:\/{scope}\/{name}", + "target" : "path:\/{scope}\/{name}", + "targetFallback" : "GET \/{scope}\/{name}" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "200" + }, + { + "kind" : "requirementOf", + "source" : "response:200", + "target" : "schema:Releases", + "targetFallback" : "Releases" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:404", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "404" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:get:\/{scope}\/{name}", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "path:\/login", + "target" : "module", + "targetFallback" : "\/login" + }, + { + "kind" : "memberOf", + "source" : "operation:post:\/login", + "target" : "path:\/login", + "targetFallback" : "POST \/login" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:post:\/login", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "response:501", + "target" : "operation:post:\/login", + "targetFallback" : "501" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:post:\/login", + "targetFallback" : "200" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:post:\/login", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "path:\/{scope}\/{name}\/{version}.zip", + "target" : "module", + "targetFallback" : "\/{scope}\/{name}\/{version}.zip" + }, + { + "kind" : "memberOf", + "source" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "target" : "path:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "GET \/{scope}\/{name}\/{version}.zip" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "response:303", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "303" + }, + { + "kind" : "memberOf", + "source" : "response:404", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "404" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:get:\/{scope}\/{name}\/{version}.zip", + "targetFallback" : "200" + }, + { + "kind" : "memberOf", + "source" : "path:\/identifiers", + "target" : "module", + "targetFallback" : "\/identifiers" + }, + { + "kind" : "memberOf", + "source" : "operation:get:\/identifiers", + "target" : "path:\/identifiers", + "targetFallback" : "GET \/identifiers" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:get:\/identifiers", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:get:\/identifiers", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:get:\/identifiers", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:get:\/identifiers", + "targetFallback" : "200" + }, + { + "kind" : "requirementOf", + "source" : "response:200", + "target" : "schema:Identifiers", + "targetFallback" : "Identifiers" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:get:\/identifiers", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "path:\/{scope}\/{name}\/{version}", + "target" : "module", + "targetFallback" : "\/{scope}\/{name}\/{version}" + }, + { + "kind" : "memberOf", + "source" : "operation:get:\/{scope}\/{name}\/{version}", + "target" : "path:\/{scope}\/{name}\/{version}", + "targetFallback" : "GET \/{scope}\/{name}\/{version}" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "200" + }, + { + "kind" : "requirementOf", + "source" : "response:200", + "target" : "schema:ReleaseMetadata", + "targetFallback" : "ReleaseMetadata" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "response:404", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "404" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:get:\/{scope}\/{name}\/{version}", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "operation:put:\/{scope}\/{name}\/{version}", + "target" : "path:\/{scope}\/{name}\/{version}", + "targetFallback" : "PUT \/{scope}\/{name}\/{version}" + }, + { + "kind" : "memberOf", + "source" : "parameter:X-Swift-Package-Signature-Format", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "X-Swift-Package-Signature-Format" + }, + { + "kind" : "memberOf", + "source" : "parameter:Prefer", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "Prefer" + }, + { + "kind" : "memberOf", + "source" : "response:422", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "422" + }, + { + "kind" : "requirementOf", + "source" : "response:422", + "target" : "schema:ProblemDetails", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "response:409", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "409" + }, + { + "kind" : "requirementOf", + "source" : "response:409", + "target" : "schema:ProblemDetails", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "response:202", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "202" + }, + { + "kind" : "memberOf", + "source" : "response:201", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "201" + }, + { + "kind" : "requirementOf", + "source" : "response:201", + "target" : "schema:PublishResponse", + "targetFallback" : "PublishResponse" + }, + { + "kind" : "memberOf", + "source" : "response:405", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "405" + }, + { + "kind" : "requirementOf", + "source" : "response:405", + "target" : "schema:ProblemDetails", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "response:413", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "413" + }, + { + "kind" : "requirementOf", + "source" : "response:413", + "target" : "schema:ProblemDetails", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "response:404", + "target" : "operation:put:\/{scope}\/{name}\/{version}", + "targetFallback" : "404" + }, + { + "kind" : "memberOf", + "source" : "path:\/{scope}\/{name}\/{version}\/Package.swift", + "target" : "module", + "targetFallback" : "\/{scope}\/{name}\/{version}\/Package.swift" + }, + { + "kind" : "memberOf", + "source" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "target" : "path:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "GET \/{scope}\/{name}\/{version}\/Package.swift" + }, + { + "kind" : "memberOf", + "source" : "parameter:swift-version", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "swift-version" + }, + { + "kind" : "memberOf", + "source" : "response:200", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "200" + }, + { + "kind" : "memberOf", + "source" : "response:404", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "404" + }, + { + "kind" : "memberOf", + "source" : "response:429", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "429" + }, + { + "kind" : "memberOf", + "source" : "response:400", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "400" + }, + { + "kind" : "memberOf", + "source" : "response:303", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "303" + }, + { + "kind" : "memberOf", + "source" : "response:401", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "401" + }, + { + "kind" : "memberOf", + "source" : "response:415", + "target" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift", + "targetFallback" : "415" + }, + { + "kind" : "memberOf", + "source" : "schema:PackageOrganization", + "target" : "module", + "targetFallback" : "PackageOrganization" + }, + { + "kind" : "memberOf", + "source" : "schema:ProblemDetails", + "target" : "module", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "schema:ReleaseSignature", + "target" : "module", + "targetFallback" : "ReleaseSignature" + }, + { + "kind" : "memberOf", + "source" : "schema:Identifiers", + "target" : "module", + "targetFallback" : "Identifiers" + }, + { + "kind" : "memberOf", + "source" : "schema:PublishResponse", + "target" : "module", + "targetFallback" : "PublishResponse" + }, + { + "kind" : "memberOf", + "source" : "schema:Releases", + "target" : "module", + "targetFallback" : "Releases" + }, + { + "kind" : "memberOf", + "source" : "schema:PackageMetadata", + "target" : "module", + "targetFallback" : "PackageMetadata" + }, + { + "kind" : "requirementOf", + "source" : "schema:PackageMetadata", + "target" : "schema:PackageAuthor", + "targetFallback" : "PackageAuthor" + }, + { + "kind" : "memberOf", + "source" : "schema:PackageAuthor", + "target" : "module", + "targetFallback" : "PackageAuthor" + }, + { + "kind" : "requirementOf", + "source" : "schema:PackageAuthor", + "target" : "schema:PackageOrganization", + "targetFallback" : "PackageOrganization" + }, + { + "kind" : "memberOf", + "source" : "schema:ReleaseMetadata", + "target" : "module", + "targetFallback" : "ReleaseMetadata" + }, + { + "kind" : "requirementOf", + "source" : "schema:ReleaseMetadata", + "target" : "schema:PackageMetadata", + "targetFallback" : "PackageMetadata" + }, + { + "kind" : "requirementOf", + "source" : "schema:ReleaseMetadata", + "target" : "schema:Identifier", + "targetFallback" : "Identifier" + }, + { + "kind" : "memberOf", + "source" : "schema:ReleaseResource", + "target" : "module", + "targetFallback" : "ReleaseResource" + }, + { + "kind" : "requirementOf", + "source" : "schema:ReleaseResource", + "target" : "schema:ReleaseSignature", + "targetFallback" : "ReleaseSignature" + }, + { + "kind" : "memberOf", + "source" : "schema:ListedRelease", + "target" : "module", + "targetFallback" : "ListedRelease" + }, + { + "kind" : "requirementOf", + "source" : "schema:ListedRelease", + "target" : "schema:ProblemDetails", + "targetFallback" : "ProblemDetails" + }, + { + "kind" : "memberOf", + "source" : "schema:Identifier", + "target" : "module", + "targetFallback" : "Identifier" + } + ], + "symbols" : [ + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Parameters:**" + }, + { + "text" : "- `swift-version` (query, Optional): " + }, + { + "text" : "" + }, + { + "text" : "**Responses:**" + }, + { + "text" : "- `200`: Retrieve the manifest file for the specified package release" + }, + { + "text" : "- `404`: Referenced response" + }, + { + "text" : "- `429`: Referenced response" + }, + { + "text" : "- `400`: Referenced response" + }, + { + "text" : "- `303`: Redirect to the unqualified Package.swift resource." + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `415`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:get:\/{scope}\/{name}\/{version}\/Package.swift" + }, + "kind" : { + "displayName" : "HTTP GET", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "GET \/{scope}\/{name}\/{version}\/Package.swift" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "GET" + } + ], + "title" : "Fetch manifest for a package release" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}\/Package.swift", + "get" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "The request to publish the package has been accepted and is being processed" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:202" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "202 Response" + } + ], + "title" : "202 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "202" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/{scope}\/{name}\/{version}.zip" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/{scope}\/{name}\/{version}.zip" + } + ], + "title" : "\/{scope}\/{name}\/{version}.zip" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}.zip" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `message` (Optional): " + }, + { + "text" : "- `url` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:PublishResponse" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "PublishResponse" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "PublishResponse" + }, + "pathComponents" : [ + "PublishResponse" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Parameters:**" + }, + { + "text" : "- `X-Swift-Package-Signature-Format` (header, Optional): " + }, + { + "text" : "- `Prefer` (header, Optional): " + }, + { + "text" : "" + }, + { + "text" : "**Request Body:**" + }, + { + "text" : "Content Type: `multipart\/form-data`" + }, + { + "text" : "" + }, + { + "text" : "" + }, + { + "text" : "**Responses:**" + }, + { + "text" : "- `422`: Unprocessable entity - refused to publish the release." + }, + { + "text" : "- `429`: Referenced response" + }, + { + "text" : "- `409`: Conflict - an existing release already exists, or the release is still processing." + }, + { + "text" : "- `202`: The request to publish the package has been accepted and is being processed" + }, + { + "text" : "- `201`: The package release has been successfully published" + }, + { + "text" : "- `405`: Method not allowed - publishing is not supported on this server." + }, + { + "text" : "- `415`: Referenced response" + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `400`: Referenced response" + }, + { + "text" : "- `413`: Content too large." + }, + { + "text" : "- `404`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:put:\/{scope}\/{name}\/{version}" + }, + "kind" : { + "displayName" : "HTTP PUT", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "PUT \/{scope}\/{name}\/{version}" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "PUT" + } + ], + "title" : "Create a package release" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `description` (Optional): " + }, + { + "text" : "- `name` (Required): " + }, + { + "text" : "- `email` (Optional): " + }, + { + "text" : "- `url` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:PackageOrganization" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "PackageOrganization" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "PackageOrganization" + }, + "pathComponents" : [ + "PackageOrganization" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Responses:**" + }, + { + "text" : "- `415`: Referenced response" + }, + { + "text" : "- `200`: Retrieve detailed metadata for a specific package release" + }, + { + "text" : "- `400`: Referenced response" + }, + { + "text" : "- `404`: Referenced response" + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `429`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:get:\/{scope}\/{name}\/{version}" + }, + "kind" : { + "displayName" : "HTTP GET", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "GET \/{scope}\/{name}\/{version}" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "GET" + } + ], + "title" : "Fetch metadata for a package release" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "get" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Content too large." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:413" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "413 Response" + } + ], + "title" : "413 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "413" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Retrieve a list of all available releases for a given package" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:200" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "200 Response" + } + ], + "title" : "200 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "200" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:404" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "404 Response" + } + ], + "title" : "404 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "404" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Responses:**" + }, + { + "text" : "- `400`: Referenced response" + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `415`: Referenced response" + }, + { + "text" : "- `303`: See other - download from the URL in the Location header." + }, + { + "text" : "- `404`: Referenced response" + }, + { + "text" : "- `429`: Referenced response" + }, + { + "text" : "- `200`: Download the source archive for the specified package release" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:get:\/{scope}\/{name}\/{version}.zip" + }, + "kind" : { + "displayName" : "HTTP GET", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "GET \/{scope}\/{name}\/{version}.zip" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "GET" + } + ], + "title" : "Download source archive for a package release" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}.zip", + "get" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "See other - download from the URL in the Location header." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:303" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "303 Response" + } + ], + "title" : "303 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}.zip", + "get", + "303" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/{scope}\/{name}\/{version}\/Package.swift" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/{scope}\/{name}\/{version}\/Package.swift" + } + ], + "title" : "\/{scope}\/{name}\/{version}\/Package.swift" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}\/Package.swift" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `type` (Optional): " + }, + { + "text" : "- `status` (Optional): " + }, + { + "text" : "- `detail` (Optional): " + }, + { + "text" : "- `title` (Optional): " + }, + { + "text" : "- `instance` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:ProblemDetails" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "ProblemDetails" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "ProblemDetails" + }, + "pathComponents" : [ + "ProblemDetails" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:429" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "429 Response" + } + ], + "title" : "429 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "429" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `releases` (Required): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:Releases" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "Releases" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "Releases" + }, + "pathComponents" : [ + "Releases" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:415" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "415 Response" + } + ], + "title" : "415 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "415" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `identifiers` (Required): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:Identifiers" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "Identifiers" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "Identifiers" + }, + "pathComponents" : [ + "Identifiers" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Responses:**" + }, + { + "text" : "- `415`: Referenced response" + }, + { + "text" : "- `200`: Retrieve a list of all available releases for a given package" + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `404`: Referenced response" + }, + { + "text" : "- `400`: Referenced response" + }, + { + "text" : "- `429`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:get:\/{scope}\/{name}" + }, + "kind" : { + "displayName" : "HTTP GET", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "GET \/{scope}\/{name}" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "GET" + } + ], + "title" : "List package releases" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/identifiers" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/identifiers" + } + ], + "title" : "\/identifiers" + }, + "pathComponents" : [ + "\/identifiers" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:Identifier" + }, + "kind" : { + "displayName" : "String", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "Identifier" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "Identifier" + }, + "pathComponents" : [ + "Identifier" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Method not allowed - publishing is not supported on this server." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:405" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "405 Response" + } + ], + "title" : "405 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "405" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "parameter:X-Swift-Package-Signature-Format" + }, + "kind" : { + "displayName" : "Parameter", + "identifier" : "property" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "X-Swift-Package-Signature-Format" + } + ], + "title" : "X-Swift-Package-Signature-Format" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "X-Swift-Package-Signature-Format" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Conflict - an existing release already exists, or the release is still processing." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:409" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "409 Response" + } + ], + "title" : "409 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "409" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "parameter:swift-version" + }, + "kind" : { + "displayName" : "Parameter", + "identifier" : "property" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "swift-version" + } + ], + "title" : "swift-version" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}\/Package.swift", + "get", + "swift-version" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `name` (Required): " + }, + { + "text" : "- `organization` (Optional): " + }, + { + "text" : "- `url` (Optional): " + }, + { + "text" : "- `description` (Optional): " + }, + { + "text" : "- `email` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:PackageAuthor" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "PackageAuthor" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "PackageAuthor" + }, + "pathComponents" : [ + "PackageAuthor" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "API for managing Swift package releases and interacting with the package registry." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "module" + }, + "kind" : { + "displayName" : "Module", + "identifier" : "module" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "RegistryAPI" + } + ], + "title" : "RegistryAPI" + }, + "pathComponents" : [ + "RegistryAPI" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "parameter:Prefer" + }, + "kind" : { + "displayName" : "Parameter", + "identifier" : "property" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "Prefer" + } + ], + "title" : "Prefer" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "Prefer" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Log in using either basic or token authentication. Use the `Authorization` header to provide credentials.\n\nAlso use this endpoint to verify authentication credentials before saving them to the local secrets store." + }, + { + "text" : "" + }, + { + "text" : "**Responses:**" + }, + { + "text" : "- `429`: Referenced response" + }, + { + "text" : "- `501`: Registry does not support authentication." + }, + { + "text" : "- `200`: User successfully logged in to the package registry" + }, + { + "text" : "- `401`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:post:\/login" + }, + "kind" : { + "displayName" : "HTTP POST", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "POST \/login" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "POST" + } + ], + "title" : "Log in to the package registry" + }, + "pathComponents" : [ + "\/login", + "post" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `problem` (Optional): " + }, + { + "text" : "- `url` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:ListedRelease" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "ListedRelease" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "ListedRelease" + }, + "pathComponents" : [ + "ListedRelease" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/login" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/login" + } + ], + "title" : "\/login" + }, + "pathComponents" : [ + "\/login" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/{scope}\/{name}" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/{scope}\/{name}" + } + ], + "title" : "\/{scope}\/{name}" + }, + "pathComponents" : [ + "\/{scope}\/{name}" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:401" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "401 Response" + } + ], + "title" : "401 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "401" + ] + }, + { + "accessLevel" : "public", + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "path:\/{scope}\/{name}\/{version}" + }, + "kind" : { + "displayName" : "Path", + "identifier" : "protocol" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "\/{scope}\/{name}\/{version}" + } + ], + "title" : "\/{scope}\/{name}\/{version}" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `version` (Required): " + }, + { + "text" : "- `metadata` (Required): " + }, + { + "text" : "- `id` (Required): " + }, + { + "text" : "- `resources` (Required): " + }, + { + "text" : "- `publishedAt` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:ReleaseMetadata" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "ReleaseMetadata" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "ReleaseMetadata" + }, + "pathComponents" : [ + "ReleaseMetadata" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Registry does not support authentication." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:501" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "501 Response" + } + ], + "title" : "501 Response" + }, + "pathComponents" : [ + "\/login", + "post", + "501" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Responses:**" + }, + { + "text" : "- `401`: Referenced response" + }, + { + "text" : "- `429`: Referenced response" + }, + { + "text" : "- `415`: Referenced response" + }, + { + "text" : "- `200`: Retrieve a list of package identifiers registered for a specific URL" + }, + { + "text" : "- `400`: Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "operation:get:\/identifiers" + }, + "kind" : { + "displayName" : "HTTP GET", + "identifier" : "method" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "GET \/identifiers" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "GET" + } + ], + "title" : "Lookup package identifiers registered for a URL" + }, + "pathComponents" : [ + "\/identifiers", + "get" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `repositoryURLs` (Optional): " + }, + { + "text" : "- `author` (Optional): " + }, + { + "text" : "- `description` (Optional): " + }, + { + "text" : "- `readmeURL` (Optional): " + }, + { + "text" : "- `originalPublicationTime` (Optional): " + }, + { + "text" : "- `licenseURL` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:PackageMetadata" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "PackageMetadata" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "PackageMetadata" + }, + "pathComponents" : [ + "PackageMetadata" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Unprocessable entity - refused to publish the release." + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:422" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "422 Response" + } + ], + "title" : "422 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "422" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "The package release has been successfully published" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:201" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "201 Response" + } + ], + "title" : "201 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}\/{version}", + "put", + "201" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `name` (Required): " + }, + { + "text" : "- `checksum` (Required): " + }, + { + "text" : "- `type` (Required): " + }, + { + "text" : "- `signing` (Optional): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:ReleaseResource" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "ReleaseResource" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "ReleaseResource" + }, + "pathComponents" : [ + "ReleaseResource" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "Referenced response" + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "response:400" + }, + "kind" : { + "displayName" : "Response", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "400 Response" + } + ], + "title" : "400 Response" + }, + "pathComponents" : [ + "\/{scope}\/{name}", + "get", + "400" + ] + }, + { + "accessLevel" : "public", + "docComment" : { + "lines" : [ + { + "text" : "**Properties:**" + }, + { + "text" : "- `signatureFormat` (Required): " + }, + { + "text" : "- `signatureBase64Encoded` (Required): " + } + ] + }, + "identifier" : { + "interfaceLanguage" : "openapi", + "precise" : "schema:ReleaseSignature" + }, + "kind" : { + "displayName" : "Object", + "identifier" : "struct" + }, + "names" : { + "navigator" : [ + { + "kind" : "text", + "spelling" : "ReleaseSignature" + } + ], + "subHeading" : [ + { + "kind" : "text", + "spelling" : "Schema" + } + ], + "title" : "ReleaseSignature" + }, + "pathComponents" : [ + "ReleaseSignature" + ] + } + ] +} \ No newline at end of file diff --git a/symbolgraphs/api.symbolgraph.json b/symbolgraphs/api.symbolgraph.json deleted file mode 100644 index aeaf7fa6..00000000 --- a/symbolgraphs/api.symbolgraph.json +++ /dev/null @@ -1,110 +0,0 @@ -{ - "metadata" : { - "formatVersion" : { - "major" : 1, - "minor" : 0, - "patch" : 0 - }, - "generator" : "OpenAPItoSymbolGraph" - }, - "module" : { - "isVirtual" : false, - "name" : "SampleAPI", - "platform" : { - "vendor" : "OpenAPI" - } - }, - "relationships" : [ - { - "kind" : "memberOf", - "source" : "s:SampleAPI", - "target" : "f:SampleAPI.get__users", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SampleAPI", - "target" : "s:SampleAPI.User", - "targetFallback" : null - } - ], - "symbols" : [ - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Get all users\n\nReturns a list of users\n\nPath: \/users\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SampleAPI.get__users" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Get all users\n\nReturns a list of users\n\nPath: \/users\nMethod: GET", - "title" : "get__users" - }, - "pathComponents" : [ - "SampleAPI", - "get__users" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for User" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SampleAPI.User" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for User", - "title" : "User" - }, - "pathComponents" : [ - "SampleAPI", - "User" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "A sample API for testing OpenAPI to DocC conversion" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SampleAPI" - }, - "kind" : { - "displayName" : "Module", - "identifier" : "module" - }, - "names" : { - "prose" : "A sample API for testing OpenAPI to DocC conversion", - "title" : "Sample API" - }, - "pathComponents" : [ - "SampleAPI" - ] - } - ] -} \ No newline at end of file diff --git a/symbolgraphs/petstore.symbolgraph.json b/symbolgraphs/petstore.symbolgraph.json deleted file mode 100644 index ed81866d..00000000 --- a/symbolgraphs/petstore.symbolgraph.json +++ /dev/null @@ -1,846 +0,0 @@ -{ - "metadata" : { - "formatVersion" : { - "major" : 1, - "minor" : 0, - "patch" : 0 - }, - "generator" : "OpenAPItoSymbolGraph" - }, - "module" : { - "isVirtual" : false, - "name" : "SwaggerPetstoreOpenAPI30", - "platform" : { - "vendor" : "OpenAPI" - } - }, - "relationships" : [ - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.deleteUser", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.getUserByName", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.updateUser", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.findPetsByStatus", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.deletePet", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.updatePetWithForm", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.getPetById", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.createUsersWithListInput", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.getInventory", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.placeOrder", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.updatePet", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.addPet", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.findPetsByTags", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.loginUser", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.getOrderById", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.deleteOrder", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.uploadFile", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.createUser", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "f:SwaggerPetstoreOpenAPI30.logoutUser", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.Category", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.Tag", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.Order", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.User", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.ApiResponse", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:SwaggerPetstoreOpenAPI30", - "target" : "s:SwaggerPetstoreOpenAPI30.Pet", - "targetFallback" : null - } - ], - "symbols" : [ - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Update an existing pet.\n\nUpdate an existing pet by Id.\n\nPath: \/pet\nMethod: PUT" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.updatePet" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Update an existing pet.\n\nUpdate an existing pet by Id.\n\nPath: \/pet\nMethod: PUT", - "title" : "updatePet" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "updatePet" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Place an order for a pet.\n\nPlace a new order in the store.\n\nPath: \/store\/order\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.placeOrder" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Place an order for a pet.\n\nPlace a new order in the store.\n\nPath: \/store\/order\nMethod: POST", - "title" : "placeOrder" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "placeOrder" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "This is a sample Pet Store Server based on the OpenAPI 3.0 specification. You can find out more about\nSwagger at [https:\/\/swagger.io](https:\/\/swagger.io). In the third iteration of the pet store, we've switched to the design first approach!\nYou can now help us improve the API whether it's by making changes to the definition itself or to the code.\nThat way, with time, we can improve the API in general, and expose some of the new features in OAS3.\n\nSome useful links:\n- [The Pet Store repository](https:\/\/github.com\/swagger-api\/swagger-petstore)\n- [The source API definition for the Pet Store](https:\/\/github.com\/swagger-api\/swagger-petstore\/blob\/master\/src\/main\/resources\/openapi.yaml)" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30" - }, - "kind" : { - "displayName" : "Module", - "identifier" : "module" - }, - "names" : { - "prose" : "This is a sample Pet Store Server based on the OpenAPI 3.0 specification. You can find out more about\nSwagger at [https:\/\/swagger.io](https:\/\/swagger.io). In the third iteration of the pet store, we've switched to the design first approach!\nYou can now help us improve the API whether it's by making changes to the definition itself or to the code.\nThat way, with time, we can improve the API in general, and expose some of the new features in OAS3.\n\nSome useful links:\n- [The Pet Store repository](https:\/\/github.com\/swagger-api\/swagger-petstore)\n- [The source API definition for the Pet Store](https:\/\/github.com\/swagger-api\/swagger-petstore\/blob\/master\/src\/main\/resources\/openapi.yaml)", - "title" : "Swagger Petstore - OpenAPI 3.0" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Logs out current logged in user session.\n\nLog user out of the system.\n\nPath: \/user\/logout\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.logoutUser" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Logs out current logged in user session.\n\nLog user out of the system.\n\nPath: \/user\/logout\nMethod: GET", - "title" : "logoutUser" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "logoutUser" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Get user by user name.\n\nGet user detail based on username.\n\nPath: \/user\/{username}\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.getUserByName" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Get user by user name.\n\nGet user detail based on username.\n\nPath: \/user\/{username}\nMethod: GET", - "title" : "getUserByName" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "getUserByName" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Delete user resource.\n\nThis can only be done by the logged in user.\n\nPath: \/user\/{username}\nMethod: DELETE" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.deleteUser" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Delete user resource.\n\nThis can only be done by the logged in user.\n\nPath: \/user\/{username}\nMethod: DELETE", - "title" : "deleteUser" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "deleteUser" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Finds Pets by status.\n\nMultiple status values can be provided with comma separated strings.\n\nPath: \/pet\/findByStatus\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.findPetsByStatus" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Finds Pets by status.\n\nMultiple status values can be provided with comma separated strings.\n\nPath: \/pet\/findByStatus\nMethod: GET", - "title" : "findPetsByStatus" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "findPetsByStatus" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for Pet" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.Pet" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for Pet", - "title" : "Pet" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "Pet" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for Order" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.Order" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for Order", - "title" : "Order" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "Order" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Find pet by ID.\n\nReturns a single pet.\n\nPath: \/pet\/{petId}\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.getPetById" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Find pet by ID.\n\nReturns a single pet.\n\nPath: \/pet\/{petId}\nMethod: GET", - "title" : "getPetById" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "getPetById" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Finds Pets by tags.\n\nMultiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.\n\nPath: \/pet\/findByTags\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.findPetsByTags" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Finds Pets by tags.\n\nMultiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.\n\nPath: \/pet\/findByTags\nMethod: GET", - "title" : "findPetsByTags" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "findPetsByTags" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Logs user into the system.\n\nLog into the system.\n\nPath: \/user\/login\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.loginUser" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Logs user into the system.\n\nLog into the system.\n\nPath: \/user\/login\nMethod: GET", - "title" : "loginUser" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "loginUser" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Uploads an image.\n\nUpload image of the pet.\n\nPath: \/pet\/{petId}\/uploadImage\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.uploadFile" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Uploads an image.\n\nUpload image of the pet.\n\nPath: \/pet\/{petId}\/uploadImage\nMethod: POST", - "title" : "uploadFile" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "uploadFile" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Create user.\n\nThis can only be done by the logged in user.\n\nPath: \/user\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.createUser" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Create user.\n\nThis can only be done by the logged in user.\n\nPath: \/user\nMethod: POST", - "title" : "createUser" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "createUser" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Deletes a pet.\n\nDelete a pet.\n\nPath: \/pet\/{petId}\nMethod: DELETE" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.deletePet" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Deletes a pet.\n\nDelete a pet.\n\nPath: \/pet\/{petId}\nMethod: DELETE", - "title" : "deletePet" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "deletePet" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Delete purchase order by identifier.\n\nFor valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.\n\nPath: \/store\/order\/{orderId}\nMethod: DELETE" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.deleteOrder" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Delete purchase order by identifier.\n\nFor valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.\n\nPath: \/store\/order\/{orderId}\nMethod: DELETE", - "title" : "deleteOrder" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "deleteOrder" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for Category" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.Category" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for Category", - "title" : "Category" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "Category" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for Tag" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.Tag" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for Tag", - "title" : "Tag" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "Tag" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Update user resource.\n\nThis can only be done by the logged in user.\n\nPath: \/user\/{username}\nMethod: PUT" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.updateUser" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Update user resource.\n\nThis can only be done by the logged in user.\n\nPath: \/user\/{username}\nMethod: PUT", - "title" : "updateUser" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "updateUser" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Returns pet inventories by status.\n\nReturns a map of status codes to quantities.\n\nPath: \/store\/inventory\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.getInventory" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Returns pet inventories by status.\n\nReturns a map of status codes to quantities.\n\nPath: \/store\/inventory\nMethod: GET", - "title" : "getInventory" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "getInventory" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Find purchase order by ID.\n\nFor valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.\n\nPath: \/store\/order\/{orderId}\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.getOrderById" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Find purchase order by ID.\n\nFor valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.\n\nPath: \/store\/order\/{orderId}\nMethod: GET", - "title" : "getOrderById" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "getOrderById" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for ApiResponse" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.ApiResponse" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for ApiResponse", - "title" : "ApiResponse" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "ApiResponse" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Schema for User" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:SwaggerPetstoreOpenAPI30.User" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "Schema for User", - "title" : "User" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "User" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Creates list of users with given input array.\n\nCreates list of users with given input array.\n\nPath: \/user\/createWithList\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.createUsersWithListInput" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Creates list of users with given input array.\n\nCreates list of users with given input array.\n\nPath: \/user\/createWithList\nMethod: POST", - "title" : "createUsersWithListInput" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "createUsersWithListInput" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Updates a pet in the store with form data.\n\nUpdates a pet resource based on the form data.\n\nPath: \/pet\/{petId}\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.updatePetWithForm" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Updates a pet in the store with form data.\n\nUpdates a pet resource based on the form data.\n\nPath: \/pet\/{petId}\nMethod: POST", - "title" : "updatePetWithForm" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "updatePetWithForm" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Add a new pet to the store.\n\nAdd a new pet to the store.\n\nPath: \/pet\nMethod: POST" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:SwaggerPetstoreOpenAPI30.addPet" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Add a new pet to the store.\n\nAdd a new pet to the store.\n\nPath: \/pet\nMethod: POST", - "title" : "addPet" - }, - "pathComponents" : [ - "SwaggerPetstoreOpenAPI30", - "addPet" - ] - } - ] -} \ No newline at end of file diff --git a/symbolgraphs/test-api.symbolgraph.json b/symbolgraphs/test-api.symbolgraph.json deleted file mode 100644 index ede8116e..00000000 --- a/symbolgraphs/test-api.symbolgraph.json +++ /dev/null @@ -1,211 +0,0 @@ -{ - "metadata" : { - "formatVersion" : { - "major" : 1, - "minor" : 0, - "patch" : 0 - }, - "generator" : "OpenAPItoSymbolGraph" - }, - "module" : { - "isVirtual" : false, - "name" : "API", - "platform" : { - "operatingSystem" : { - "name" : "macosx" - } - } - }, - "relationships" : [ - { - "kind" : "memberOf", - "source" : "s:API", - "target" : "s:API.User", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:API.User", - "target" : "s:API.User.id", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:API.User", - "target" : "s:API.User.name", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:API.User", - "target" : "s:API.User.email", - "targetFallback" : null - }, - { - "kind" : "memberOf", - "source" : "s:API", - "target" : "f:API.getUsers", - "targetFallback" : null - } - ], - "symbols" : [ - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "A user of the system with id, name, and email properties." - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:API.User" - }, - "kind" : { - "displayName" : "Structure", - "identifier" : "struct" - }, - "names" : { - "prose" : "A user of the system", - "title" : "User" - }, - "pathComponents" : [ - "API", - "User" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "The user's unique identifier" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:API.User.id" - }, - "kind" : { - "displayName" : "Property", - "identifier" : "property" - }, - "names" : { - "prose" : "The user's unique identifier", - "title" : "id" - }, - "pathComponents" : [ - "API", - "User", - "id" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "API Documentation" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:API" - }, - "kind" : { - "displayName" : "Module", - "identifier" : "module" - }, - "names" : { - "prose" : "API Documentation", - "title" : "API" - }, - "pathComponents" : [ - "API" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "The user's name" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:API.User.name" - }, - "kind" : { - "displayName" : "Property", - "identifier" : "property" - }, - "names" : { - "prose" : "The user's name", - "title" : "name" - }, - "pathComponents" : [ - "API", - "User", - "name" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "The user's email address" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "s:API.User.email" - }, - "kind" : { - "displayName" : "Property", - "identifier" : "property" - }, - "names" : { - "prose" : "The user's email address", - "title" : "email" - }, - "pathComponents" : [ - "API", - "User", - "email" - ] - }, - { - "accessLevel" : "public", - "docComment" : { - "lines" : [ - { - "text" : "Get all users\n\nPath: \/users\nMethod: GET" - } - ] - }, - "identifier" : { - "interfaceLanguage" : "swift", - "precise" : "f:API.getUsers" - }, - "kind" : { - "displayName" : "Function", - "identifier" : "func" - }, - "names" : { - "prose" : "Get all users", - "title" : "getUsers" - }, - "pathComponents" : [ - "API", - "getUsers" - ] - } - ] -} \ No newline at end of file