{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "soundcheck": {
      "type": "object",
      "properties": {
        "collectors": {
          "type": "object",
          "properties": {
            "scm": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "url": {
                      "type": "string",
                      "deprecated": "Use string[] instead, e.g. ['https://example.com/config.yaml']"
                    }
                  },
                  "required": [
                    "url"
                  ]
                },
                {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                },
                {
                  "type": "object",
                  "properties": {
                    "frequency": {
                      "anyOf": [
                        {
                          "type": "object",
                          "properties": {
                            "cron": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "cron"
                          ]
                        },
                        {
                          "type": "object",
                          "properties": {
                            "years": {
                              "type": "number"
                            },
                            "months": {
                              "type": "number"
                            },
                            "weeks": {
                              "type": "number"
                            },
                            "days": {
                              "type": "number"
                            },
                            "hours": {
                              "type": "number"
                            },
                            "minutes": {
                              "type": "number"
                            },
                            "seconds": {
                              "type": "number"
                            },
                            "milliseconds": {
                              "type": "number"
                            }
                          },
                          "description": "Human friendly durations object."
                        }
                      ]
                    },
                    "initialDelay": {
                      "anyOf": [
                        {
                          "type": "object",
                          "properties": {
                            "years": {
                              "type": "number"
                            },
                            "months": {
                              "type": "number"
                            },
                            "weeks": {
                              "type": "number"
                            },
                            "days": {
                              "type": "number"
                            },
                            "hours": {
                              "type": "number"
                            },
                            "minutes": {
                              "type": "number"
                            },
                            "seconds": {
                              "type": "number"
                            },
                            "milliseconds": {
                              "type": "number"
                            }
                          },
                          "description": "Human friendly durations object."
                        },
                        {
                          "type": "string"
                        }
                      ]
                    },
                    "batchSize": {
                      "type": "number"
                    },
                    "filter": {
                      "anyOf": [
                        {
                          "type": "object",
                          "additionalProperties": {
                            "anyOf": [
                              {
                                "type": "string"
                              },
                              {
                                "type": "array",
                                "items": {
                                  "type": "string"
                                }
                              }
                            ]
                          }
                        },
                        {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "additionalProperties": {
                              "anyOf": [
                                {
                                  "type": "string"
                                },
                                {
                                  "type": "array",
                                  "items": {
                                    "type": "string"
                                  }
                                }
                              ]
                            }
                          }
                        }
                      ],
                      "description": "Entity filter, similar to the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery } ."
                    },
                    "filterQuery": {
                      "anyOf": [
                        {
                          "type": "object",
                          "additionalProperties": {
                            "anyOf": [
                              {
                                "not": {}
                              },
                              {
                                "type": [
                                  "string",
                                  "number",
                                  "boolean",
                                  "object"
                                ]
                              }
                            ]
                          },
                          "properties": {},
                          "description": "A filter predicate expression that matches against one or more object properties."
                        },
                        {
                          "type": [
                            "string",
                            "number",
                            "boolean"
                          ],
                          "description": "A primitive value that can be used in filter predicates."
                        },
                        {
                          "type": "object",
                          "properties": {
                            "$all": {
                              "type": "array",
                              "items": {
                                "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893"
                              },
                              "description": "Asserts that all of the given predicates must be true."
                            }
                          },
                          "required": [
                            "$all"
                          ]
                        },
                        {
                          "type": "object",
                          "properties": {
                            "$any": {
                              "type": "array",
                              "items": {
                                "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893"
                              },
                              "description": "Asserts that at least one of the given predicates must be true."
                            }
                          },
                          "required": [
                            "$any"
                          ]
                        },
                        {
                          "type": "object",
                          "properties": {
                            "$not": {
                              "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893",
                              "description": "Asserts that the given predicate must not be true."
                            }
                          },
                          "required": [
                            "$not"
                          ]
                        },
                        {
                          "type": "object",
                          "additionalProperties": {
                            "type": [
                              "object",
                              "number",
                              "string",
                              "boolean",
                              "null"
                            ]
                          },
                          "properties": {
                            "$all": {
                              "not": {}
                            },
                            "$any": {
                              "not": {}
                            },
                            "$not": {
                              "not": {}
                            }
                          },
                          "required": [
                            "$all",
                            "$any",
                            "$not"
                          ],
                          "description": "Represents future additions to the set of filter predicate operators."
                        }
                      ],
                      "description": "A filter predicate that can be evaluated against a value."
                    },
                    "exclude": {
                      "anyOf": [
                        {
                          "type": "object",
                          "additionalProperties": {
                            "anyOf": [
                              {
                                "type": "string"
                              },
                              {
                                "type": "array",
                                "items": {
                                  "type": "string"
                                }
                              }
                            ]
                          }
                        },
                        {
                          "type": "array",
                          "items": {
                            "type": "object",
                            "additionalProperties": {
                              "anyOf": [
                                {
                                  "type": "string"
                                },
                                {
                                  "type": "array",
                                  "items": {
                                    "type": "string"
                                  }
                                }
                              ]
                            }
                          }
                        }
                      ],
                      "description": "Entity filter, similar to the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery } ."
                    },
                    "cache": {
                      "anyOf": [
                        {
                          "type": "object",
                          "properties": {
                            "duration": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "years": {
                                      "type": "number"
                                    },
                                    "months": {
                                      "type": "number"
                                    },
                                    "weeks": {
                                      "type": "number"
                                    },
                                    "days": {
                                      "type": "number"
                                    },
                                    "hours": {
                                      "type": "number"
                                    },
                                    "minutes": {
                                      "type": "number"
                                    },
                                    "seconds": {
                                      "type": "number"
                                    },
                                    "milliseconds": {
                                      "type": "number"
                                    }
                                  },
                                  "description": "Human friendly durations object."
                                },
                                {
                                  "type": "string"
                                }
                              ]
                            }
                          },
                          "required": [
                            "duration"
                          ]
                        },
                        {
                          "type": "boolean"
                        }
                      ]
                    },
                    "cacheFullResultsForEtags": {
                      "type": "boolean",
                      "description": "Caches the full SCM response instead of just the facts to be used with etags. Can reduce the number of api calls to SCM when the same glob pattern is being used for multiple facts. Will increase the memory requirements for caching.",
                      "visibility": "backend"
                    },
                    "collects": {
                      "type": "array",
                      "items": {
                        "anyOf": [
                          {
                            "type": "object",
                            "properties": {
                              "data": {
                                "type": "array",
                                "items": {
                                  "type": "object",
                                  "properties": {
                                    "name": {
                                      "type": "string",
                                      "description": "Name of the field within the resulting facts data schema."
                                    },
                                    "path": {
                                      "type": "string",
                                      "description": "The path to look for the existence of the file at."
                                    }
                                  },
                                  "required": [
                                    "name",
                                    "path"
                                  ],
                                  "description": "Data Schema for  {@link  FileExistsExtractorConfig }"
                                },
                                "description": "Describes the data to be extracted."
                              },
                              "factName": {
                                "type": "string",
                                "description": "The name of the fact to be extracted."
                              },
                              "type": {
                                "type": "string",
                                "description": "The type of extraction to be performed."
                              },
                              "frequency": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "cron": {
                                        "type": "string",
                                        "description": "A crontab style string."
                                      }
                                    },
                                    "required": [
                                      "cron"
                                    ]
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The frequency at which the specifised facts should be collected. If not provided it defaults to the frequency provided at the top level."
                              },
                              "initialDelay": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The initial delay before the first collection of the specified facts."
                              },
                              "batchSize": {
                                "type": "number",
                                "description": "A number of entities the fact collection will be scheduled for at once (if configured).\n\nIf not provided defaults to a single entity."
                              },
                              "branch": {
                                "type": "string",
                                "description": "The branch to extract the fact from. If not provided, defaults to the repo's default branch."
                              },
                              "filter": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to collect the specified facts for.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "exclude": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to exclude from collection.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "cache": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "duration": {
                                        "anyOf": [
                                          {
                                            "type": "object",
                                            "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                          },
                                          {
                                            "type": "object",
                                            "properties": {
                                              "years": {
                                                "type": "number"
                                              },
                                              "months": {
                                                "type": "number"
                                              },
                                              "weeks": {
                                                "type": "number"
                                              },
                                              "days": {
                                                "type": "number"
                                              },
                                              "hours": {
                                                "type": "number"
                                              },
                                              "minutes": {
                                                "type": "number"
                                              },
                                              "seconds": {
                                                "type": "number"
                                              },
                                              "milliseconds": {
                                                "type": "number"
                                              }
                                            },
                                            "description": "Human friendly durations object."
                                          }
                                        ]
                                      }
                                    },
                                    "required": [
                                      "duration"
                                    ]
                                  },
                                  {
                                    "type": "boolean"
                                  }
                                ],
                                "description": "If the collected facts should be cached, and if so for how long.\n\nIf not provided facts will not be cached."
                              }
                            },
                            "required": [
                              "data",
                              "type"
                            ],
                            "description": "Extracts a fact on the existence of files within an SCM repository."
                          },
                          {
                            "type": "object",
                            "properties": {
                              "path": {
                                "type": "string",
                                "description": "The path of the JSON, YAML, or XML file."
                              },
                              "data": {
                                "type": "array",
                                "items": {
                                  "type": "object",
                                  "properties": {
                                    "name": {
                                      "type": "string",
                                      "description": "A name for the data to be extracted,"
                                    },
                                    "jsonPath": {
                                      "type": "string",
                                      "description": "A JSON Path pointing to the element to extract."
                                    },
                                    "type": {
                                      "type": "string",
                                      "description": "A JSON Schema representation of the data’s type."
                                    },
                                    "items": {
                                      "type": "object",
                                      "properties": {
                                        "type": {
                                          "type": "string",
                                          "description": "A type of array items in case if  {@link  JsonPathDataSchema } .type is array."
                                        }
                                      },
                                      "required": [
                                        "type"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "name",
                                    "jsonPath",
                                    "type"
                                  ],
                                  "description": "Data Schema for  {@link  JsonYamlPathExtractorConfig }"
                                },
                                "description": "An array describing the data to be extracted."
                              },
                              "factName": {
                                "type": "string",
                                "description": "The name of the fact to be extracted."
                              },
                              "type": {
                                "type": "string",
                                "description": "The type of extraction to be performed."
                              },
                              "frequency": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "cron": {
                                        "type": "string",
                                        "description": "A crontab style string."
                                      }
                                    },
                                    "required": [
                                      "cron"
                                    ]
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The frequency at which the specifised facts should be collected. If not provided it defaults to the frequency provided at the top level."
                              },
                              "initialDelay": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The initial delay before the first collection of the specified facts."
                              },
                              "batchSize": {
                                "type": "number",
                                "description": "A number of entities the fact collection will be scheduled for at once (if configured).\n\nIf not provided defaults to a single entity."
                              },
                              "branch": {
                                "type": "string",
                                "description": "The branch to extract the fact from. If not provided, defaults to the repo's default branch."
                              },
                              "filter": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to collect the specified facts for.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "exclude": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to exclude from collection.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "cache": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "duration": {
                                        "anyOf": [
                                          {
                                            "type": "object",
                                            "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                          },
                                          {
                                            "type": "object",
                                            "properties": {
                                              "years": {
                                                "type": "number"
                                              },
                                              "months": {
                                                "type": "number"
                                              },
                                              "weeks": {
                                                "type": "number"
                                              },
                                              "days": {
                                                "type": "number"
                                              },
                                              "hours": {
                                                "type": "number"
                                              },
                                              "minutes": {
                                                "type": "number"
                                              },
                                              "seconds": {
                                                "type": "number"
                                              },
                                              "milliseconds": {
                                                "type": "number"
                                              }
                                            },
                                            "description": "Human friendly durations object."
                                          }
                                        ]
                                      }
                                    },
                                    "required": [
                                      "duration"
                                    ]
                                  },
                                  {
                                    "type": "boolean"
                                  }
                                ],
                                "description": "If the collected facts should be cached, and if so for how long.\n\nIf not provided facts will not be cached."
                              }
                            },
                            "required": [
                              "data",
                              "path",
                              "type"
                            ],
                            "description": "Extracts data from a JSON/YAML/XML file at specified JSON paths."
                          },
                          {
                            "type": "object",
                            "properties": {
                              "path": {
                                "type": "string",
                                "description": "Path to the file to extract data from."
                              },
                              "regex": {
                                "type": "string",
                                "description": "A regular expression to execute on the file. Should include one or more capture groups."
                              },
                              "data": {
                                "type": "array",
                                "items": {
                                  "type": "object",
                                  "properties": {
                                    "name": {
                                      "type": "string",
                                      "description": "A name for the data to be extracted."
                                    },
                                    "type": {
                                      "type": "string",
                                      "description": "A JSON Schema representation of the data’s type."
                                    }
                                  },
                                  "required": [
                                    "name",
                                    "type"
                                  ],
                                  "description": "Data Schema for  {@link  RegexExtractorConfig }"
                                },
                                "description": "An array describing the data to be extracted. The order of the elements in this array corresponds to the capture groups within the regular expression. If omitted, the extractor simply returns true or false based on whether the regular expression matched."
                              },
                              "flags": {
                                "type": "string",
                                "description": "Optional flags to use when executing the regular expression."
                              },
                              "matchAll": {
                                "type": "boolean",
                                "description": "When true, finds all matches in the file rather than just the first. Returns `{ matchCount: number, matches: string[] }` instead of `{ matches: boolean }`. The global flag (`g`) is automatically applied. Cannot be used together with `data` (capture groups)."
                              },
                              "factName": {
                                "type": "string",
                                "description": "The name of the fact to be extracted."
                              },
                              "type": {
                                "type": "string",
                                "description": "The type of extraction to be performed."
                              },
                              "frequency": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "cron": {
                                        "type": "string",
                                        "description": "A crontab style string."
                                      }
                                    },
                                    "required": [
                                      "cron"
                                    ]
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The frequency at which the specifised facts should be collected. If not provided it defaults to the frequency provided at the top level."
                              },
                              "initialDelay": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                  },
                                  {
                                    "type": "object",
                                    "properties": {
                                      "years": {
                                        "type": "number"
                                      },
                                      "months": {
                                        "type": "number"
                                      },
                                      "weeks": {
                                        "type": "number"
                                      },
                                      "days": {
                                        "type": "number"
                                      },
                                      "hours": {
                                        "type": "number"
                                      },
                                      "minutes": {
                                        "type": "number"
                                      },
                                      "seconds": {
                                        "type": "number"
                                      },
                                      "milliseconds": {
                                        "type": "number"
                                      }
                                    },
                                    "description": "Human friendly durations object."
                                  }
                                ],
                                "description": "The initial delay before the first collection of the specified facts."
                              },
                              "batchSize": {
                                "type": "number",
                                "description": "A number of entities the fact collection will be scheduled for at once (if configured).\n\nIf not provided defaults to a single entity."
                              },
                              "branch": {
                                "type": "string",
                                "description": "The branch to extract the fact from. If not provided, defaults to the repo's default branch."
                              },
                              "filter": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to collect the specified facts for.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "exclude": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "additionalProperties": {
                                      "anyOf": [
                                        {
                                          "type": "string"
                                        },
                                        {
                                          "type": "array",
                                          "items": {
                                            "type": "string"
                                          }
                                        }
                                      ]
                                    }
                                  },
                                  {
                                    "type": "array",
                                    "items": {
                                      "type": "object",
                                      "additionalProperties": {
                                        "anyOf": [
                                          {
                                            "type": "string"
                                          },
                                          {
                                            "type": "array",
                                            "items": {
                                              "type": "string"
                                            }
                                          }
                                        ]
                                      }
                                    }
                                  }
                                ],
                                "description": "A filter specifying which entities to exclude from collection.\n\nMatches the filter format used by the Catalog API:  {@link  https://backstage.io/docs/reference/catalog-client.entityfilterquery }"
                              },
                              "cache": {
                                "anyOf": [
                                  {
                                    "type": "object",
                                    "properties": {
                                      "duration": {
                                        "anyOf": [
                                          {
                                            "type": "object",
                                            "description": "A Duration object represents a period of time, like \"2 months\" or \"1 day, 1 hour\". Conceptually, it is just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use  {@link  DateTime.plus  }  to add a Duration object to a DateTime, producing another DateTime.\n\nHere is a brief overview of commonly used methods and getters in Duration:\n\n* **Creation** To create a Duration, use  {@link  Duration.fromMillis } ,  {@link  Duration.fromObject } , or  {@link  Duration.fromISO } .\n* **Unit values** See the  {@link  Duration#years  } ,  {@link  Duration.months } ,  {@link  Duration#weeks  } ,  {@link  Duration#days  } ,  {@link  Duration#hours  } ,  {@link  Duration#minutes  } ,\n*  {@link  Duration#seconds  } ,  {@link  Duration#milliseconds  }  accessors.\n* **Configuration** See   {@link  Duration#locale  }  and  {@link  Duration#numberingSystem  }  accessors.\n* **Transformation** To create new Durations out of old ones use  {@link  Duration#plus  } ,  {@link  Duration#minus  } ,  {@link  Duration#normalize  } ,  {@link  Duration#set  } ,  {@link  Duration#reconfigure  } ,\n*  {@link  Duration#shiftTo  } , and  {@link  Duration#negate  } .\n* **Output** To convert the Duration into other representations, see  {@link  Duration#as  } ,  {@link  Duration#toISO  } ,  {@link  Duration#toFormat  } , and  {@link  Duration#toJSON  } \n\nThere's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation."
                                          },
                                          {
                                            "type": "object",
                                            "properties": {
                                              "years": {
                                                "type": "number"
                                              },
                                              "months": {
                                                "type": "number"
                                              },
                                              "weeks": {
                                                "type": "number"
                                              },
                                              "days": {
                                                "type": "number"
                                              },
                                              "hours": {
                                                "type": "number"
                                              },
                                              "minutes": {
                                                "type": "number"
                                              },
                                              "seconds": {
                                                "type": "number"
                                              },
                                              "milliseconds": {
                                                "type": "number"
                                              }
                                            },
                                            "description": "Human friendly durations object."
                                          }
                                        ]
                                      }
                                    },
                                    "required": [
                                      "duration"
                                    ]
                                  },
                                  {
                                    "type": "boolean"
                                  }
                                ],
                                "description": "If the collected facts should be cached, and if so for how long.\n\nIf not provided facts will not be cached."
                              }
                            },
                            "required": [
                              "path",
                              "regex",
                              "type"
                            ],
                            "description": "Executes one or more regular expressions against a specified file and extracts its capture groups into fact data."
                          }
                        ]
                      }
                    }
                  }
                },
                {
                  "type": "object",
                  "properties": {
                    "cacheFullResultsForEtags": {
                      "type": "boolean",
                      "description": "Caches the full SCM response instead of just the facts to be used with etags. Can reduce the number of api calls to SCM when the same glob pattern is being used for multiple facts. Will increase the memory requirements for caching.",
                      "visibility": "backend"
                    }
                  }
                }
              ],
              "description": "Configuration options for Soundcheck SCM Fact Collector.\n\nWhen configured as a string array, entries are treated as remote URLs. URLs ending with '/' are treated as directory URLs — all .yaml/.yml files in the directory are automatically discovered and loaded. New files added to a directory are picked up on the next scheduled remote file update without requiring a config change or redeploy.",
              "visibility": "backend"
            }
          },
          "description": "Yaml configuration options for Soundcheck Fact Collectors. Optional, fact collectors can also be configured via No-Code UI.",
          "visibility": "backend"
        }
      },
      "description": "Configuration options for the soundcheck plugin."
    }
  },
  "definitions": {
    "c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": {
            "anyOf": [
              {
                "not": {}
              },
              {
                "type": [
                  "string",
                  "number",
                  "boolean",
                  "object"
                ]
              }
            ]
          },
          "properties": {},
          "description": "A filter predicate expression that matches against one or more object properties."
        },
        {
          "type": [
            "string",
            "number",
            "boolean"
          ],
          "description": "A primitive value that can be used in filter predicates."
        },
        {
          "type": "object",
          "properties": {
            "$all": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893"
              },
              "description": "Asserts that all of the given predicates must be true."
            }
          },
          "required": [
            "$all"
          ]
        },
        {
          "type": "object",
          "properties": {
            "$any": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893"
              },
              "description": "Asserts that at least one of the given predicates must be true."
            }
          },
          "required": [
            "$any"
          ]
        },
        {
          "type": "object",
          "properties": {
            "$not": {
              "$ref": "#/definitions/c773477720f2fd94fc72041a14a027e0640fac78f87a3b04a5c2ed5ca06235aa-alias-tes_dist_index.d.ts-596-2580-tes_dist_index.d.ts-0-7406235801893",
              "description": "Asserts that the given predicate must not be true."
            }
          },
          "required": [
            "$not"
          ]
        },
        {
          "type": "object",
          "additionalProperties": {
            "type": [
              "object",
              "number",
              "string",
              "boolean",
              "null"
            ]
          },
          "properties": {
            "$all": {
              "not": {}
            },
            "$any": {
              "not": {}
            },
            "$not": {
              "not": {}
            }
          },
          "required": [
            "$all",
            "$any",
            "$not"
          ],
          "description": "Represents future additions to the set of filter predicate operators."
        }
      ],
      "description": "A filter predicate that can be evaluated against a value."
    }
  }
}
