openapi.json

{
  "openapi": "3.1.0",
  "info": {
    "title": "Profilarr API",
    "description": "API for Profilarr - Profile management and sync for *arr applications",
    "version": "1.0.0",
    "license": {
      "name": "MIT",
      "url": "https://opensource.org/licenses/MIT"
    }
  },
  "servers": [
    {
      "url": "/api/v1",
      "description": "API v1"
    }
  ],
  "tags": [
    {
      "name": "System",
      "description": "System health and status endpoints"
    },
    {
      "name": "Entity Testing",
      "description": "Release parsing and custom format evaluation"
    },
    {
      "name": "Arr",
      "description": "Arr instance library and release endpoints"
    },
    {
      "name": "PCD",
      "description": "PCD entity export and portable format endpoints"
    },
    {
      "name": "Regex",
      "description": "Regex pattern validation"
    }
  ],
  "paths": {
    "/health": {
      "get": {
        "operationId": "getHealth",
        "summary": "Health check",
        "description": "Returns the health status of the application and its components.\n\nStatus values:\n- `healthy`: All components functioning normally\n- `degraded`: Core functionality works but some components have issues\n- `unhealthy`: Core functionality is broken\n\nUse `?verbose=true` for detailed component information.\n",
        "tags": [
          "System"
        ],
        "parameters": [
          {
            "name": "verbose",
            "in": "query",
            "description": "Include detailed component information",
            "schema": {
              "type": "boolean",
              "default": false
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Health check response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HealthResponse"
                }
              }
            }
          }
        }
      }
    },
    "/openapi.json": {
      "get": {
        "operationId": "getOpenApiSpec",
        "summary": "OpenAPI specification",
        "description": "Returns the OpenAPI specification for this API",
        "tags": [
          "System"
        ],
        "responses": {
          "200": {
            "description": "OpenAPI specification",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      }
    },
    "/entity-testing/evaluate": {
      "post": {
        "operationId": "evaluateReleases",
        "summary": "Evaluate releases against custom formats",
        "description": "Parses release titles and evaluates them against all custom formats in the specified database.\n\nThis endpoint:\n- Parses each release title to extract metadata (resolution, source, languages, etc.)\n- Matches regex patterns using .NET-compatible regex via the parser service\n- Evaluates each release against all custom formats in the database\n- Returns which custom formats match each release\n\nResults are cached for performance - repeated requests with the same titles will be faster.\n",
        "tags": [
          "Entity Testing"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EvaluateRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Evaluation results",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EvaluateResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid request (missing databaseId or releases)"
          },
          "500": {
            "description": "Database cache not available"
          }
        }
      }
    },
    "/arr/library": {
      "get": {
        "operationId": "getLibrary",
        "summary": "Get Arr instance library",
        "description": "Fetches the full movie or series library from an Arr instance with quality profile,\nscore, and progress information.\n\n- For Radarr: Returns movies with file quality, custom format scores, and cutoff progress\n- For Sonarr: Returns series with season summaries and episode statistics\n\nResults include Profilarr profile matching to indicate which items use managed profiles.\nResponses are cached server-side for 5 minutes.\n",
        "tags": [
          "Arr"
        ],
        "parameters": [
          {
            "name": "instanceId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Arr instance ID"
          }
        ],
        "responses": {
          "200": {
            "description": "Library items with quality and score data",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LibraryResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid or missing instanceId",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Instance not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Failed to fetch library",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      },
      "delete": {
        "operationId": "invalidateLibraryCache",
        "summary": "Invalidate library cache",
        "description": "Clears the server-side cache for an Arr instance's library data.\nThe next GET request will fetch fresh data from the Arr instance.\n",
        "tags": [
          "Arr"
        ],
        "parameters": [
          {
            "name": "instanceId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Arr instance ID"
          }
        ],
        "responses": {
          "200": {
            "description": "Cache invalidated",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CacheInvalidatedResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid or missing instanceId",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/arr/library/episodes": {
      "get": {
        "operationId": "getLibraryEpisodes",
        "summary": "Get episode details for a Sonarr series",
        "description": "Lazy-loads episode-level data for a specific series in a Sonarr instance.\nReturns episodes with quality, custom format scores, and cutoff progress.\n\nThis endpoint is designed for on-demand loading when a series row is expanded\nin the library view. Sonarr instances only.\n\nResults are cached server-side for 5 minutes per series.\n",
        "tags": [
          "Arr"
        ],
        "parameters": [
          {
            "name": "instanceId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Arr instance ID (must be a Sonarr instance)"
          },
          {
            "name": "seriesId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Sonarr series ID"
          }
        ],
        "responses": {
          "200": {
            "description": "Episode details with quality and score data",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EpisodesResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters or not a Sonarr instance",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Instance not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Failed to fetch episode details",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/arr/releases": {
      "get": {
        "operationId": "getReleases",
        "summary": "Search for releases",
        "description": "Triggers an interactive search on an Arr instance and returns grouped/deduplicated results.\n\nFor Radarr: Searches for releases for the specified movie.\nFor Sonarr: Searches for season pack releases for the specified series and season.\n\nResults are grouped by title, combining information from multiple indexers.\n",
        "tags": [
          "Arr"
        ],
        "parameters": [
          {
            "name": "instanceId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Arr instance ID"
          },
          {
            "name": "itemId",
            "in": "query",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "Movie ID (Radarr) or Series ID (Sonarr)"
          },
          {
            "name": "season",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 1
            },
            "description": "Season number for Sonarr searches (defaults to 1)"
          }
        ],
        "responses": {
          "200": {
            "description": "Release search results",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ReleasesResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid or missing parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Instance not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Failed to fetch releases",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/arr/cleanup": {
      "post": {
        "operationId": "arrCleanup",
        "summary": "Scan or execute cleanup of stale configs",
        "description": "Detects and deletes stale namespace-suffixed custom formats and quality profiles\nfrom an Arr instance that are no longer in the current sync selections.\n\nTwo actions are supported via the `action` field in the request body:\n- `scan`: Scans for stale items and returns what would be deleted.\n- `execute`: Deletes the stale items from a previous scan result.\n\nQuality profiles assigned to media will be skipped with a warning (Arr returns HTTP 500 \"in use\").\n",
        "tags": [
          "Arr"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/CleanupScanRequest"
                  },
                  {
                    "$ref": "#/components/schemas/CleanupExecuteRequest"
                  }
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Scan or delete result",
            "content": {
              "application/json": {
                "schema": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/CleanupScanResult"
                    },
                    {
                      "$ref": "#/components/schemas/CleanupDeleteResult"
                    }
                  ]
                }
              }
            }
          },
          "400": {
            "description": "Invalid request (missing instanceId, invalid action)",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Instance not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Failed to perform cleanup",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/arr/sync-entity": {
      "post": {
        "operationId": "syncEntity",
        "summary": "Sync a single entity to an Arr instance",
        "description": "Pushes a single entity to an Arr instance. Runs inline and returns when complete.\n\nEntity types are grouped into sync sections that share cooldown and status tracking:\n  - **qualityProfiles**: qualityProfile, customFormat, regularExpression\n  - **delayProfiles**: delayProfile\n  - **mediaManagement**: naming, qualityDefinitions, mediaSettings\n\nThe section is derived automatically from the entity type. A 5-second cooldown\nis enforced per section per instance — entity types within the same section share\nthe cooldown. Returns 409 if a sync is already in progress or the cooldown is active.\n",
        "tags": [
          "Arr"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SyncEntityRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Entity synced successfully",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SyncEntitySuccessResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid request parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Instance not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "409": {
            "description": "Cooldown active or sync in progress",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SyncEntityCooldownResponse"
                }
              }
            }
          },
          "500": {
            "description": "Sync failed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/pcd/export": {
      "get": {
        "operationId": "exportEntity",
        "summary": "Export a portable entity",
        "description": "Serializes a PCD entity into its portable JSON representation.\n\nThe portable format strips database IDs and timestamps, producing a\nself-contained snapshot suitable for clipboard copy, file export, or\ncross-database import.\n",
        "tags": [
          "PCD"
        ],
        "parameters": [
          {
            "name": "databaseId",
            "in": "query",
            "required": true,
            "description": "The PCD database ID to export from",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "entityType",
            "in": "query",
            "required": true,
            "description": "The entity type to export",
            "schema": {
              "$ref": "#/components/schemas/EntityType"
            }
          },
          {
            "name": "name",
            "in": "query",
            "required": true,
            "description": "The entity name to export",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Portable entity JSON",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ExportResponse"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Entity not found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Database cache not available",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/pcd/import": {
      "post": {
        "operationId": "importEntity",
        "summary": "Import a portable entity",
        "description": "Deserializes a portable entity into PCD operations, creating the entity\nin the target database and layer.\n\nThe request body matches the export response format (`entityType` + `data`),\nplus `databaseId` and `layer` to specify the target.\n\nName uniqueness is validated — importing an entity with a name that already\nexists will return a 400 error.\n",
        "tags": [
          "PCD"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ImportRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Entity created successfully",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ImportResponse"
                }
              }
            }
          },
          "400": {
            "description": "Validation error (missing fields, duplicate name, invalid data)",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          },
          "403": {
            "description": "Cannot write to base layer",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Database cache not available",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PcdErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/regex/validate": {
      "post": {
        "operationId": "validateRegex",
        "summary": "Validate a .NET regex pattern",
        "description": "Validates a regex pattern using the .NET regex engine (via the parser service).\nThis matches the exact validation Radarr and Sonarr perform when importing custom formats.\nIf the parser service is offline, returns { valid: true } to avoid blocking saves.\n",
        "tags": [
          "Regex"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ValidateRegexRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Validation result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ValidateRegexResponse"
                }
              }
            }
          },
          "400": {
            "description": "Missing pattern"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "ComponentStatus": {
        "type": "string",
        "enum": [
          "healthy",
          "degraded",
          "unhealthy"
        ],
        "description": "Individual component health status"
      },
      "HealthStatus": {
        "type": "string",
        "enum": [
          "healthy",
          "degraded",
          "unhealthy"
        ],
        "description": "Overall health status"
      },
      "SqliteHealth": {
        "type": "object",
        "required": [
          "status",
          "responseTimeMs",
          "migration"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/ComponentStatus"
          },
          "responseTimeMs": {
            "type": "number",
            "description": "Database query response time in milliseconds"
          },
          "migration": {
            "type": "integer",
            "description": "Current migration version"
          },
          "message": {
            "type": "string",
            "description": "Error message if unhealthy"
          }
        }
      },
      "ReposHealth": {
        "type": "object",
        "required": [
          "status"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/ComponentStatus"
          },
          "message": {
            "type": "string",
            "description": "Additional status information"
          },
          "total": {
            "type": "integer",
            "description": "Total number of PCD repos configured (verbose only)"
          },
          "enabled": {
            "type": "integer",
            "description": "Number of enabled repos (verbose only)"
          },
          "cached": {
            "type": "integer",
            "description": "Number of repos with compiled cache (verbose only)"
          },
          "disabled": {
            "type": "integer",
            "description": "Number of disabled repos (verbose only)"
          }
        }
      },
      "JobsHealth": {
        "type": "object",
        "required": [
          "status"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/ComponentStatus"
          },
          "message": {
            "type": "string",
            "description": "Additional status information"
          },
          "lastRun": {
            "type": "object",
            "additionalProperties": {
              "type": "string",
              "format": "date-time",
              "nullable": true
            },
            "description": "Last run time for each job (verbose only)"
          }
        }
      },
      "BackupsHealth": {
        "type": "object",
        "required": [
          "status",
          "enabled"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/ComponentStatus"
          },
          "enabled": {
            "type": "boolean",
            "description": "Whether backups are enabled"
          },
          "message": {
            "type": "string",
            "description": "Additional status information"
          },
          "lastBackup": {
            "type": "string",
            "format": "date-time",
            "nullable": true,
            "description": "Timestamp of last backup (verbose only)"
          },
          "count": {
            "type": "integer",
            "description": "Number of backup files (verbose only)"
          },
          "totalSize": {
            "type": "string",
            "description": "Human-readable total size of all backups (verbose only)"
          },
          "retentionDays": {
            "type": "integer",
            "description": "Configured retention period in days (verbose only)"
          }
        }
      },
      "LogsHealth": {
        "type": "object",
        "required": [
          "status"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/ComponentStatus"
          },
          "message": {
            "type": "string",
            "description": "Additional status information"
          },
          "totalSize": {
            "type": "string",
            "description": "Human-readable total size of log files (verbose only)"
          },
          "fileCount": {
            "type": "integer",
            "description": "Number of log files (verbose only)"
          },
          "oldestLog": {
            "type": "string",
            "format": "date",
            "nullable": true,
            "description": "Date of oldest log file (verbose only)"
          },
          "newestLog": {
            "type": "string",
            "format": "date",
            "nullable": true,
            "description": "Date of newest log file (verbose only)"
          }
        }
      },
      "HealthResponse": {
        "type": "object",
        "required": [
          "status",
          "timestamp",
          "version",
          "uptime",
          "components"
        ],
        "properties": {
          "status": {
            "$ref": "#/components/schemas/HealthStatus"
          },
          "timestamp": {
            "type": "string",
            "format": "date-time",
            "description": "Current server time"
          },
          "version": {
            "type": "string",
            "description": "Application version"
          },
          "uptime": {
            "type": "integer",
            "description": "Server uptime in seconds"
          },
          "components": {
            "type": "object",
            "required": [
              "sqlite",
              "repos",
              "jobs",
              "backups",
              "logs"
            ],
            "properties": {
              "sqlite": {
                "$ref": "#/components/schemas/SqliteHealth"
              },
              "repos": {
                "$ref": "#/components/schemas/ReposHealth"
              },
              "jobs": {
                "$ref": "#/components/schemas/JobsHealth"
              },
              "backups": {
                "$ref": "#/components/schemas/BackupsHealth"
              },
              "logs": {
                "$ref": "#/components/schemas/LogsHealth"
              }
            }
          }
        }
      },
      "MediaType": {
        "type": "string",
        "enum": [
          "movie",
          "series"
        ],
        "description": "Type of media"
      },
      "ParsedInfo": {
        "type": "object",
        "required": [
          "source",
          "resolution",
          "modifier",
          "languages",
          "languageSource",
          "year"
        ],
        "properties": {
          "source": {
            "type": "string",
            "description": "Detected source (e.g., bluray, webdl, webrip)"
          },
          "resolution": {
            "type": "string",
            "description": "Detected resolution (e.g., 1080p, 2160p)"
          },
          "modifier": {
            "type": "string",
            "description": "Quality modifier (e.g., remux, none)"
          },
          "languages": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Detected languages"
          },
          "languageSource": {
            "type": "string",
            "enum": [
              "Indexer",
              "Title"
            ],
            "description": "Where the language information came from (Indexer = indexer-provided, Title = parsed from release title)"
          },
          "releaseGroup": {
            "type": "string",
            "nullable": true,
            "description": "Detected release group"
          },
          "year": {
            "type": "integer",
            "description": "Detected year"
          },
          "edition": {
            "type": "string",
            "nullable": true,
            "description": "Detected edition (e.g., Director's Cut)"
          },
          "releaseType": {
            "type": "string",
            "nullable": true,
            "description": "Release type for series (single_episode, season_pack, etc.)"
          }
        }
      },
      "ReleaseInput": {
        "type": "object",
        "required": [
          "id",
          "title",
          "type"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Release ID"
          },
          "title": {
            "type": "string",
            "description": "Release title to parse and evaluate"
          },
          "type": {
            "$ref": "#/components/schemas/MediaType"
          },
          "languages": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Indexer-provided languages. When present and non-empty, these override languages parsed from the title."
          }
        }
      },
      "ReleaseEvaluation": {
        "type": "object",
        "required": [
          "releaseId",
          "title",
          "cfMatches"
        ],
        "properties": {
          "releaseId": {
            "type": "integer",
            "description": "Release ID"
          },
          "title": {
            "type": "string",
            "description": "Release title"
          },
          "parsed": {
            "$ref": "#/components/schemas/ParsedInfo"
          },
          "cfMatches": {
            "type": "object",
            "additionalProperties": {
              "type": "boolean"
            },
            "description": "Map of custom format ID to whether it matches"
          }
        }
      },
      "EvaluateRequest": {
        "type": "object",
        "required": [
          "releases"
        ],
        "properties": {
          "databaseId": {
            "type": "integer",
            "description": "Database ID to use for custom format evaluation. If omitted, only parsing is performed (no CF matching)."
          },
          "releases": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ReleaseInput"
            },
            "description": "Releases to evaluate"
          }
        }
      },
      "EvaluateResponse": {
        "type": "object",
        "required": [
          "parserAvailable",
          "evaluations"
        ],
        "properties": {
          "parserAvailable": {
            "type": "boolean",
            "description": "Whether the parser service is available"
          },
          "evaluations": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ReleaseEvaluation"
            },
            "description": "Evaluation results for each release"
          }
        }
      },
      "ArrType": {
        "type": "string",
        "enum": [
          "radarr",
          "sonarr"
        ],
        "description": "Type of Arr instance"
      },
      "CustomFormatRef": {
        "type": "object",
        "required": [
          "id",
          "name"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Custom format ID"
          },
          "name": {
            "type": "string",
            "description": "Custom format name"
          }
        }
      },
      "ScoreBreakdownItem": {
        "type": "object",
        "required": [
          "name",
          "score"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "Custom format name"
          },
          "score": {
            "type": "integer",
            "description": "Score assigned by the quality profile"
          }
        }
      },
      "ProfileByDatabase": {
        "type": "object",
        "required": [
          "databaseId",
          "databaseName",
          "profiles"
        ],
        "properties": {
          "databaseId": {
            "type": "integer",
            "description": "Profilarr database ID"
          },
          "databaseName": {
            "type": "string",
            "description": "Profilarr database name"
          },
          "profiles": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Quality profile names in this database"
          }
        }
      },
      "RadarrLibraryItem": {
        "type": "object",
        "required": [
          "id",
          "title",
          "hasFile",
          "qualityProfileId",
          "qualityProfileName",
          "isProfilarrProfile",
          "customFormatScore",
          "cutoffScore",
          "minScore",
          "progress",
          "cutoffMet",
          "customFormats",
          "scoreBreakdown"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Radarr movie ID"
          },
          "tmdbId": {
            "type": "integer",
            "description": "TMDB ID"
          },
          "title": {
            "type": "string",
            "description": "Movie title"
          },
          "year": {
            "type": "integer",
            "description": "Release year"
          },
          "qualityProfileId": {
            "type": "integer",
            "description": "Assigned quality profile ID"
          },
          "qualityProfileName": {
            "type": "string",
            "description": "Assigned quality profile name"
          },
          "hasFile": {
            "type": "boolean",
            "description": "Whether the movie has a downloaded file"
          },
          "dateAdded": {
            "type": "string",
            "format": "date-time",
            "description": "When the movie was added"
          },
          "popularity": {
            "type": "number",
            "description": "TMDB popularity score"
          },
          "qualityName": {
            "type": "string",
            "nullable": true,
            "description": "Quality of the downloaded file (null if no file)"
          },
          "fileName": {
            "type": "string",
            "nullable": true,
            "description": "File name of the downloaded file (null if no file)"
          },
          "customFormats": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/CustomFormatRef"
            },
            "description": "Custom formats matched on the file"
          },
          "customFormatScore": {
            "type": "integer",
            "description": "Total custom format score"
          },
          "scoreBreakdown": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ScoreBreakdownItem"
            },
            "description": "Per-custom-format score breakdown"
          },
          "cutoffScore": {
            "type": "integer",
            "description": "Profile cutoff score threshold"
          },
          "minScore": {
            "type": "integer",
            "description": "Profile minimum score threshold"
          },
          "progress": {
            "type": "number",
            "description": "Score progress toward cutoff (0-1+)"
          },
          "cutoffMet": {
            "type": "boolean",
            "description": "Whether the cutoff score has been met"
          },
          "isProfilarrProfile": {
            "type": "boolean",
            "description": "Whether the profile is managed by Profilarr"
          }
        }
      },
      "SonarrSeasonItem": {
        "type": "object",
        "required": [
          "seasonNumber",
          "monitored",
          "episodeCount",
          "episodeFileCount",
          "totalEpisodeCount",
          "sizeOnDisk",
          "percentOfEpisodes"
        ],
        "properties": {
          "seasonNumber": {
            "type": "integer",
            "description": "Season number (0 = specials)"
          },
          "monitored": {
            "type": "boolean",
            "description": "Whether this season is monitored"
          },
          "episodeCount": {
            "type": "integer",
            "description": "Number of aired episodes"
          },
          "episodeFileCount": {
            "type": "integer",
            "description": "Number of episodes with files"
          },
          "totalEpisodeCount": {
            "type": "integer",
            "description": "Total episodes including unaired"
          },
          "sizeOnDisk": {
            "type": "integer",
            "description": "Total size of episode files in bytes"
          },
          "percentOfEpisodes": {
            "type": "number",
            "description": "Percentage of episodes with files (0-100)"
          }
        }
      },
      "SonarrLibraryItem": {
        "type": "object",
        "required": [
          "id",
          "title",
          "qualityProfileId",
          "qualityProfileName",
          "monitored",
          "seasonCount",
          "episodeCount",
          "episodeFileCount",
          "totalEpisodeCount",
          "sizeOnDisk",
          "percentOfEpisodes",
          "seasons",
          "isProfilarrProfile"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Sonarr series ID"
          },
          "tvdbId": {
            "type": "integer",
            "description": "TVDB ID"
          },
          "title": {
            "type": "string",
            "description": "Series title"
          },
          "year": {
            "type": "integer",
            "description": "First air year"
          },
          "qualityProfileId": {
            "type": "integer",
            "description": "Assigned quality profile ID"
          },
          "qualityProfileName": {
            "type": "string",
            "description": "Assigned quality profile name"
          },
          "status": {
            "type": "string",
            "description": "Series status (continuing, ended, etc.)"
          },
          "monitored": {
            "type": "boolean",
            "description": "Whether the series is monitored"
          },
          "seasonCount": {
            "type": "integer",
            "description": "Number of seasons"
          },
          "episodeCount": {
            "type": "integer",
            "description": "Number of aired episodes"
          },
          "episodeFileCount": {
            "type": "integer",
            "description": "Number of episodes with files"
          },
          "totalEpisodeCount": {
            "type": "integer",
            "description": "Total episodes including unaired"
          },
          "sizeOnDisk": {
            "type": "integer",
            "description": "Total size of all episode files in bytes"
          },
          "percentOfEpisodes": {
            "type": "number",
            "description": "Percentage of episodes with files (0-100)"
          },
          "dateAdded": {
            "type": "string",
            "format": "date-time",
            "description": "When the series was added"
          },
          "seasons": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SonarrSeasonItem"
            },
            "description": "Season-level statistics"
          },
          "isProfilarrProfile": {
            "type": "boolean",
            "description": "Whether the profile is managed by Profilarr"
          }
        }
      },
      "SonarrEpisodeItem": {
        "type": "object",
        "required": [
          "id",
          "episodeNumber",
          "seasonNumber",
          "title",
          "hasFile",
          "monitored",
          "customFormatScore",
          "cutoffScore",
          "progress",
          "cutoffMet",
          "customFormats",
          "scoreBreakdown"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Sonarr episode ID"
          },
          "episodeNumber": {
            "type": "integer",
            "description": "Episode number within the season"
          },
          "seasonNumber": {
            "type": "integer",
            "description": "Season number"
          },
          "title": {
            "type": "string",
            "description": "Episode title"
          },
          "hasFile": {
            "type": "boolean",
            "description": "Whether the episode has a downloaded file"
          },
          "monitored": {
            "type": "boolean",
            "description": "Whether the episode is monitored"
          },
          "qualityName": {
            "type": "string",
            "description": "Quality of the downloaded file"
          },
          "fileName": {
            "type": "string",
            "description": "File name of the downloaded file"
          },
          "size": {
            "type": "integer",
            "description": "File size in bytes"
          },
          "customFormats": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/CustomFormatRef"
            },
            "description": "Custom formats matched on the file"
          },
          "customFormatScore": {
            "type": "integer",
            "description": "Total custom format score"
          },
          "scoreBreakdown": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ScoreBreakdownItem"
            },
            "description": "Per-custom-format score breakdown"
          },
          "cutoffScore": {
            "type": "integer",
            "description": "Profile cutoff score threshold"
          },
          "progress": {
            "type": "number",
            "description": "Score progress toward cutoff (0-1+)"
          },
          "cutoffMet": {
            "type": "boolean",
            "description": "Whether the cutoff score has been met"
          }
        }
      },
      "LibraryRadarrResponse": {
        "type": "object",
        "required": [
          "type",
          "items",
          "profilesByDatabase"
        ],
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "radarr"
            ]
          },
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/RadarrLibraryItem"
            }
          },
          "profilesByDatabase": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProfileByDatabase"
            }
          }
        }
      },
      "LibrarySonarrResponse": {
        "type": "object",
        "required": [
          "type",
          "items",
          "profilesByDatabase"
        ],
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "sonarr"
            ]
          },
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SonarrLibraryItem"
            }
          },
          "profilesByDatabase": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProfileByDatabase"
            }
          }
        }
      },
      "LibraryResponse": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/LibraryRadarrResponse"
          },
          {
            "$ref": "#/components/schemas/LibrarySonarrResponse"
          }
        ],
        "description": "Library response varies by instance type"
      },
      "EpisodesResponse": {
        "type": "object",
        "required": [
          "episodes"
        ],
        "properties": {
          "episodes": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SonarrEpisodeItem"
            },
            "description": "Episode details with quality and score data"
          }
        }
      },
      "CacheInvalidatedResponse": {
        "type": "object",
        "required": [
          "success"
        ],
        "properties": {
          "success": {
            "type": "boolean",
            "description": "Whether the cache was invalidated"
          }
        }
      },
      "GroupedRelease": {
        "type": "object",
        "required": [
          "title",
          "size",
          "languages",
          "indexers",
          "flags"
        ],
        "properties": {
          "title": {
            "type": "string",
            "description": "Release title"
          },
          "size": {
            "type": "integer",
            "description": "Release size in bytes"
          },
          "languages": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Languages detected in the release"
          },
          "indexers": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Indexers where this release was found"
          },
          "flags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Release flags (e.g., freeleech, internal)"
          }
        }
      },
      "ReleasesResponse": {
        "type": "object",
        "required": [
          "type",
          "rawCount",
          "releases"
        ],
        "properties": {
          "type": {
            "$ref": "#/components/schemas/ArrType"
          },
          "rawCount": {
            "type": "integer",
            "description": "Total number of raw releases before grouping"
          },
          "releases": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/GroupedRelease"
            },
            "description": "Grouped and deduplicated releases"
          }
        }
      },
      "ErrorResponse": {
        "type": "object",
        "required": [
          "error"
        ],
        "properties": {
          "error": {
            "type": "string",
            "description": "Error message"
          }
        }
      },
      "StaleItem": {
        "type": "object",
        "required": [
          "id",
          "name",
          "strippedName"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Arr entity ID"
          },
          "name": {
            "type": "string",
            "description": "Full name including namespace suffix"
          },
          "strippedName": {
            "type": "string",
            "description": "Name with namespace suffix removed"
          }
        }
      },
      "CleanupScanRequest": {
        "type": "object",
        "required": [
          "instanceId",
          "action"
        ],
        "properties": {
          "instanceId": {
            "type": "integer",
            "description": "Arr instance ID"
          },
          "action": {
            "type": "string",
            "enum": [
              "scan"
            ]
          }
        }
      },
      "CleanupExecuteRequest": {
        "type": "object",
        "required": [
          "instanceId",
          "action",
          "scanResult"
        ],
        "properties": {
          "instanceId": {
            "type": "integer",
            "description": "Arr instance ID"
          },
          "action": {
            "type": "string",
            "enum": [
              "execute"
            ]
          },
          "scanResult": {
            "$ref": "#/components/schemas/CleanupScanResult"
          }
        }
      },
      "CleanupScanResult": {
        "type": "object",
        "required": [
          "staleCustomFormats",
          "staleQualityProfiles"
        ],
        "properties": {
          "staleCustomFormats": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/StaleItem"
            },
            "description": "Custom formats that are no longer in sync selections"
          },
          "staleQualityProfiles": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/StaleItem"
            },
            "description": "Quality profiles that are no longer in sync selections"
          }
        }
      },
      "SkippedItem": {
        "type": "object",
        "required": [
          "item",
          "reason"
        ],
        "properties": {
          "item": {
            "$ref": "#/components/schemas/StaleItem"
          },
          "reason": {
            "type": "string",
            "description": "Why the item was skipped (e.g. \"Profile is assigned to media\")"
          }
        }
      },
      "CleanupDeleteResult": {
        "type": "object",
        "required": [
          "deletedCustomFormats",
          "deletedQualityProfiles",
          "skippedQualityProfiles"
        ],
        "properties": {
          "deletedCustomFormats": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/StaleItem"
            },
            "description": "Custom formats that were successfully deleted"
          },
          "deletedQualityProfiles": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/StaleItem"
            },
            "description": "Quality profiles that were successfully deleted"
          },
          "skippedQualityProfiles": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SkippedItem"
            },
            "description": "Quality profiles that were skipped (assigned to media)"
          }
        }
      },
      "SyncEntityRequest": {
        "type": "object",
        "required": [
          "instanceId",
          "databaseId",
          "entityName",
          "entityType"
        ],
        "properties": {
          "instanceId": {
            "type": "integer",
            "description": "Arr instance ID"
          },
          "databaseId": {
            "type": "integer",
            "description": "PCD database ID"
          },
          "entityName": {
            "type": "string",
            "description": "Name of the entity to sync"
          },
          "entityType": {
            "type": "string",
            "enum": [
              "qualityProfile",
              "customFormat",
              "regularExpression",
              "delayProfile",
              "naming",
              "qualityDefinitions",
              "mediaSettings"
            ],
            "description": "Type of entity being synced. Determines which sync function runs and which cooldown group applies (qualityProfiles, delayProfiles, or mediaManagement).\n"
          }
        }
      },
      "SyncEntitySuccessResponse": {
        "type": "object",
        "required": [
          "success"
        ],
        "properties": {
          "success": {
            "type": "boolean",
            "enum": [
              true
            ]
          }
        }
      },
      "SyncEntityCooldownResponse": {
        "type": "object",
        "required": [
          "error"
        ],
        "properties": {
          "error": {
            "type": "string",
            "description": "Cooldown or in-progress message"
          },
          "retryAfter": {
            "type": "integer",
            "description": "Seconds until cooldown expires"
          }
        }
      },
      "EntityType": {
        "type": "string",
        "enum": [
          "delay_profile",
          "regular_expression",
          "custom_format",
          "quality_profile",
          "radarr_naming",
          "sonarr_naming",
          "radarr_media_settings",
          "sonarr_media_settings",
          "radarr_quality_definitions",
          "sonarr_quality_definitions"
        ]
      },
      "ExportResponse": {
        "type": "object",
        "required": [
          "entityType",
          "data"
        ],
        "properties": {
          "entityType": {
            "$ref": "#/components/schemas/EntityType"
          },
          "data": {
            "description": "The portable entity payload. Shape varies by entityType:\n- `delay_profile` → PortableDelayProfile\n- `regular_expression` → PortableRegularExpression\n- `custom_format` → PortableCustomFormat\n- `quality_profile` → PortableQualityProfile\n- `radarr_naming` → PortableRadarrNaming\n- `sonarr_naming` → PortableSonarrNaming\n- `radarr_media_settings` → PortableMediaSettings\n- `sonarr_media_settings` → PortableMediaSettings\n- `radarr_quality_definitions` → PortableQualityDefinitions\n- `sonarr_quality_definitions` → PortableQualityDefinitions\n",
            "oneOf": [
              {
                "$ref": "#/components/schemas/PortableDelayProfile"
              },
              {
                "$ref": "#/components/schemas/PortableRegularExpression"
              },
              {
                "$ref": "#/components/schemas/PortableCustomFormat"
              },
              {
                "$ref": "#/components/schemas/PortableQualityProfile"
              },
              {
                "$ref": "#/components/schemas/PortableRadarrNaming"
              },
              {
                "$ref": "#/components/schemas/PortableSonarrNaming"
              },
              {
                "$ref": "#/components/schemas/PortableMediaSettings"
              },
              {
                "$ref": "#/components/schemas/PortableQualityDefinitions"
              }
            ]
          }
        }
      },
      "BundledDependency": {
        "type": "object",
        "required": [
          "entityType",
          "data"
        ],
        "properties": {
          "entityType": {
            "type": "string",
            "description": "The entity type of the dependency"
          },
          "data": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string"
              }
            },
            "additionalProperties": true,
            "description": "The portable entity payload for the dependency"
          }
        }
      },
      "ImportConflict": {
        "type": "object",
        "required": [
          "entityType",
          "name"
        ],
        "properties": {
          "entityType": {
            "type": "string",
            "description": "The entity type that conflicts"
          },
          "name": {
            "type": "string",
            "description": "The name of the conflicting entity"
          }
        }
      },
      "ConflictResolution": {
        "type": "object",
        "required": [
          "entityType",
          "originalName",
          "action"
        ],
        "properties": {
          "entityType": {
            "type": "string",
            "description": "The entity type being resolved"
          },
          "originalName": {
            "type": "string",
            "description": "The original name of the conflicting entity"
          },
          "action": {
            "type": "string",
            "enum": [
              "skip",
              "rename"
            ],
            "description": "How to resolve the conflict"
          },
          "newName": {
            "type": "string",
            "description": "The new name when action is rename"
          }
        }
      },
      "ImportRequest": {
        "type": "object",
        "required": [
          "databaseId",
          "layer",
          "entityType",
          "data"
        ],
        "properties": {
          "databaseId": {
            "type": "integer",
            "description": "The PCD database ID to import into"
          },
          "layer": {
            "type": "string",
            "enum": [
              "user",
              "base"
            ],
            "description": "The operation layer to write to"
          },
          "entityType": {
            "$ref": "#/components/schemas/EntityType"
          },
          "data": {
            "description": "The portable entity payload (same shape as ExportResponse.data)",
            "oneOf": [
              {
                "$ref": "#/components/schemas/PortableDelayProfile"
              },
              {
                "$ref": "#/components/schemas/PortableRegularExpression"
              },
              {
                "$ref": "#/components/schemas/PortableCustomFormat"
              },
              {
                "$ref": "#/components/schemas/PortableQualityProfile"
              },
              {
                "$ref": "#/components/schemas/PortableRadarrNaming"
              },
              {
                "$ref": "#/components/schemas/PortableSonarrNaming"
              },
              {
                "$ref": "#/components/schemas/PortableMediaSettings"
              },
              {
                "$ref": "#/components/schemas/PortableQualityDefinitions"
              }
            ]
          }
        }
      },
      "ImportResponse": {
        "type": "object",
        "required": [
          "success"
        ],
        "properties": {
          "success": {
            "type": "boolean"
          }
        }
      },
      "PcdErrorResponse": {
        "type": "object",
        "required": [
          "error"
        ],
        "properties": {
          "error": {
            "type": "string"
          }
        }
      },
      "PortableDelayProfile": {
        "type": "object",
        "required": [
          "name",
          "preferredProtocol",
          "usenetDelay",
          "torrentDelay",
          "bypassIfHighestQuality",
          "bypassIfAboveCfScore",
          "minimumCfScore"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "preferredProtocol": {
            "type": "string",
            "enum": [
              "prefer_usenet",
              "prefer_torrent",
              "only_usenet",
              "only_torrent"
            ]
          },
          "usenetDelay": {
            "type": "integer"
          },
          "torrentDelay": {
            "type": "integer"
          },
          "bypassIfHighestQuality": {
            "type": "boolean"
          },
          "bypassIfAboveCfScore": {
            "type": "boolean"
          },
          "minimumCfScore": {
            "type": "integer"
          }
        }
      },
      "PortableRegularExpression": {
        "type": "object",
        "required": [
          "name",
          "pattern",
          "tags",
          "description",
          "regex101Id"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "pattern": {
            "type": "string"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "description": {
            "type": "string",
            "nullable": true
          },
          "regex101Id": {
            "type": "string",
            "nullable": true
          }
        }
      },
      "PortableCustomFormatTest": {
        "type": "object",
        "required": [
          "title",
          "type",
          "shouldMatch",
          "description"
        ],
        "properties": {
          "title": {
            "type": "string"
          },
          "type": {
            "type": "string",
            "enum": [
              "movie",
              "series"
            ]
          },
          "shouldMatch": {
            "type": "boolean"
          },
          "description": {
            "type": "string",
            "nullable": true
          }
        }
      },
      "PortableCustomFormat": {
        "type": "object",
        "required": [
          "name",
          "description",
          "includeInRename",
          "tags",
          "conditions",
          "tests"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "description": {
            "type": "string",
            "nullable": true
          },
          "includeInRename": {
            "type": "boolean"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "conditions": {
            "type": "array",
            "items": {
              "type": "object",
              "description": "Condition data (shape varies by condition type)"
            }
          },
          "tests": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PortableCustomFormatTest"
            }
          }
        }
      },
      "PortableCustomFormatScore": {
        "type": "object",
        "required": [
          "customFormatName",
          "arrType",
          "score"
        ],
        "properties": {
          "customFormatName": {
            "type": "string"
          },
          "arrType": {
            "type": "string"
          },
          "score": {
            "type": "integer"
          }
        }
      },
      "PortableQualityProfile": {
        "type": "object",
        "required": [
          "name",
          "description",
          "tags",
          "language",
          "orderedItems",
          "minimumScore",
          "upgradeUntilScore",
          "upgradeScoreIncrement",
          "customFormatScores"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "description": {
            "type": "string",
            "nullable": true
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "language": {
            "type": "string",
            "nullable": true
          },
          "orderedItems": {
            "type": "array",
            "items": {
              "type": "object",
              "description": "Ordered quality item (quality or group)"
            }
          },
          "minimumScore": {
            "type": "integer"
          },
          "upgradeUntilScore": {
            "type": "integer"
          },
          "upgradeScoreIncrement": {
            "type": "integer"
          },
          "customFormatScores": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PortableCustomFormatScore"
            }
          }
        }
      },
      "PortableRadarrNaming": {
        "type": "object",
        "required": [
          "name",
          "rename",
          "movieFormat",
          "movieFolderFormat",
          "replaceIllegalCharacters",
          "colonReplacementFormat"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rename": {
            "type": "boolean"
          },
          "movieFormat": {
            "type": "string"
          },
          "movieFolderFormat": {
            "type": "string"
          },
          "replaceIllegalCharacters": {
            "type": "boolean"
          },
          "colonReplacementFormat": {
            "type": "string"
          }
        }
      },
      "PortableSonarrNaming": {
        "type": "object",
        "required": [
          "name",
          "rename",
          "standardEpisodeFormat",
          "dailyEpisodeFormat",
          "animeEpisodeFormat",
          "seriesFolderFormat",
          "seasonFolderFormat",
          "replaceIllegalCharacters",
          "colonReplacementFormat",
          "customColonReplacementFormat",
          "multiEpisodeStyle"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "rename": {
            "type": "boolean"
          },
          "standardEpisodeFormat": {
            "type": "string"
          },
          "dailyEpisodeFormat": {
            "type": "string"
          },
          "animeEpisodeFormat": {
            "type": "string"
          },
          "seriesFolderFormat": {
            "type": "string"
          },
          "seasonFolderFormat": {
            "type": "string"
          },
          "replaceIllegalCharacters": {
            "type": "boolean"
          },
          "colonReplacementFormat": {
            "type": "string"
          },
          "customColonReplacementFormat": {
            "type": "string",
            "nullable": true
          },
          "multiEpisodeStyle": {
            "type": "string"
          }
        }
      },
      "PortableMediaSettings": {
        "type": "object",
        "required": [
          "name",
          "propersRepacks",
          "enableMediaInfo"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "propersRepacks": {
            "type": "string"
          },
          "enableMediaInfo": {
            "type": "boolean"
          }
        }
      },
      "PortableQualityDefinitions": {
        "type": "object",
        "required": [
          "name",
          "entries"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "entries": {
            "type": "array",
            "items": {
              "type": "object",
              "description": "Quality definition entry with min/max/preferred sizes"
            }
          }
        }
      },
      "ValidateRegexRequest": {
        "type": "object",
        "required": [
          "pattern"
        ],
        "properties": {
          "pattern": {
            "type": "string",
            "description": "The .NET regex pattern to validate"
          }
        }
      },
      "ValidateRegexResponse": {
        "type": "object",
        "required": [
          "valid"
        ],
        "properties": {
          "valid": {
            "type": "boolean",
            "description": "Whether the pattern is a valid .NET regex"
          },
          "error": {
            "type": "string",
            "nullable": true,
            "description": "The .NET ArgumentException message if invalid"
          },
          "available": {
            "type": "boolean",
            "nullable": true,
            "description": "Whether the parser service was reachable. False means validation was skipped."
          }
        }
      }
    }
  }
}