@redocly/config 0.43.0 → 0.44.0

package/lib/default-theme-config-schema.d.ts

@@ -5341,6 +5341,9 @@ export declare const themeConfigSchema: {
          * @deprecated Should use `scorecardClassic` instead
          */
         readonly scorecard: {
+            readonly nodeTypeName: "ScorecardClassic";
+            readonly description: "Add and create sets of rules and test your API description files against them. With these rules you can maintain quality across your existing APIs and ensure that newly-added or updated APIs match your criteria. An API scorecard can include multiple sets of rules, corresponding to different quality levels.";
+            readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic";
             readonly type: "object";
             readonly additionalProperties: true;
             readonly required: readonly [];
@@ -5350,6 +5353,9 @@ export declare const themeConfigSchema: {
                     readonly default: false;
                 };
                 readonly teamMetadataProperty: {
+                    readonly nodeTypeName: "ScorecardClassicTeamMetadataProperty";
+                    readonly description: "Provide custom team label and team metadata property.";
+                    readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#team-metadata-object";
                     readonly type: "object";
                     readonly properties: {
                         readonly property: {
@@ -5364,92 +5370,126 @@ export declare const themeConfigSchema: {
                     };
                 };
                 readonly levels: {
+                    readonly nodeTypeName: "ScorecardClassicLevelList";
+                    readonly description: "List of levels to score against.";
                     readonly type: "array";
                     readonly items: {
+                        readonly nodeTypeName: "ScorecardClassicLevel";
+                        readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#level-object";
                         readonly type: "object";
                         readonly required: readonly ["name"];
                         readonly properties: {
-                            readonly decorators: {
+                            readonly extends: {
+                                readonly nodeTypeName: undefined;
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly description: "Use extends to inherit rules and their configurations from other rulesets.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/extends";
+                            };
+                            readonly preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas2Decorators: {
+                            readonly oas2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_0Decorators: {
+                            readonly oas3_0Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_1Decorators: {
+                            readonly oas3_1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_2Decorators: {
+                            readonly oas3_2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async2Decorators: {
+                            readonly async2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async3Decorators: {
+                            readonly async3Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly arazzo1Decorators: {
+                            readonly arazzo1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly overlay1Decorators: {
+                            readonly overlay1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly openrpc1Decorators: {
+                            readonly openrpc1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly preprocessors: {
+                            readonly decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas2Preprocessors: {
+                            readonly oas2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_0Preprocessors: {
+                            readonly oas3_0Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_1Preprocessors: {
+                            readonly oas3_1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_2Preprocessors: {
+                            readonly oas3_2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async2Preprocessors: {
+                            readonly async2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async3Preprocessors: {
+                            readonly async3Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly arazzo1Preprocessors: {
+                            readonly arazzo1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly overlay1Preprocessors: {
+                            readonly overlay1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly openrpc1Preprocessors: {
+                            readonly openrpc1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
                             readonly rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5458,8 +5498,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5468,8 +5511,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_0Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5478,8 +5524,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5488,8 +5537,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5498,8 +5550,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly async2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5508,8 +5563,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly async3Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5518,8 +5576,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly arazzo1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5528,8 +5589,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly overlay1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5538,8 +5602,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly openrpc1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -5548,6 +5615,8 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly name: {
                                 readonly type: "string";
@@ -5555,19 +5624,16 @@ export declare const themeConfigSchema: {
                             readonly color: {
                                 readonly type: "string";
                             };
-                            readonly extends: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
-                                };
-                            };
                         };
                         readonly additionalProperties: false;
                     };
                 };
                 readonly targets: {
+                    readonly nodeTypeName: "ScorecardClassicTargetList";
+                    readonly description: "Provide custom `minimumLevel` for specific targets.";
                     readonly type: "array";
                     readonly items: {
+                        readonly nodeTypeName: "ScorecardClassicTarget";
                         readonly type: "object";
                         readonly required: readonly ["where"];
                         readonly properties: {
@@ -5579,10 +5645,14 @@ export declare const themeConfigSchema: {
                                 readonly additionalProperties: true;
                             };
                             readonly where: {
+                                readonly nodeTypeName: "ScorecardClassicTargetWhere";
+                                readonly description: "Specify which API descriptions to apply the `minimumLevel` to based on the metadata.";
+                                readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#where-object";
                                 readonly type: "object";
                                 readonly required: readonly ["metadata"];
                                 readonly properties: {
                                     readonly metadata: {
+                                        readonly nodeTypeName: "ScorecardClassicTargetWhereMetadata";
                                         readonly type: "object";
                                         readonly additionalProperties: {
                                             readonly type: "string";
@@ -5607,708 +5677,156 @@ export declare const themeConfigSchema: {
                 };
             };
         };
-        readonly scorecards: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly name: {
-                        readonly type: "string";
-                    };
-                    readonly key: {
-                        readonly type: "string";
-                    };
-                    readonly description: {
-                        readonly type: "string";
+        readonly scorecardClassic: {
+            readonly nodeTypeName: "ScorecardClassic";
+            readonly description: "Add and create sets of rules and test your API description files against them. With these rules you can maintain quality across your existing APIs and ensure that newly-added or updated APIs match your criteria. An API scorecard can include multiple sets of rules, corresponding to different quality levels.";
+            readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly [];
+            readonly properties: {
+                readonly ignoreNonCompliant: {
+                    readonly type: "boolean";
+                    readonly default: false;
+                };
+                readonly teamMetadataProperty: {
+                    readonly nodeTypeName: "ScorecardClassicTeamMetadataProperty";
+                    readonly description: "Provide custom team label and team metadata property.";
+                    readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#team-metadata-object";
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly property: {
+                            readonly type: "string";
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                        };
+                        readonly default: {
+                            readonly type: "string";
+                        };
                     };
-                    readonly entities: {
-                        readonly oneOf: readonly [{
-                            readonly type: "array";
-                            readonly items: {
-                                readonly oneOf: readonly [{
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly field: {
-                                            readonly type: "string";
-                                        };
-                                        readonly operator: {
-                                            readonly type: "string";
-                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                        };
-                                        readonly value: {
-                                            readonly oneOf: readonly [{
-                                                readonly type: "boolean";
-                                            }, {
-                                                readonly type: "string";
-                                            }, {
-                                                readonly type: "number";
-                                            }];
-                                        };
-                                        readonly modifier: {
-                                            readonly type: "string";
-                                            readonly enum: readonly ["not"];
-                                        };
-                                        readonly match: {
-                                            readonly type: "array";
-                                            readonly items: {
-                                                readonly type: "object";
-                                                readonly properties: {
-                                                    readonly field: {
-                                                        readonly type: "string";
-                                                    };
-                                                    readonly operator: {
-                                                        readonly type: "string";
-                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                    };
-                                                    readonly value: {
-                                                        readonly oneOf: readonly [{
-                                                            readonly type: "boolean";
-                                                        }, {
-                                                            readonly type: "string";
-                                                        }, {
-                                                            readonly type: "number";
-                                                        }];
-                                                    };
-                                                    readonly modifier: {
-                                                        readonly type: "string";
-                                                        readonly enum: readonly ["not"];
-                                                    };
-                                                };
-                                            };
-                                        };
-                                    };
-                                }, {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly operator: {
-                                            readonly type: "string";
-                                            readonly enum: readonly ["and", "or"];
-                                        };
-                                        readonly conditions: {
-                                            readonly type: "array";
-                                            readonly items: {
-                                                readonly oneOf: readonly [{
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly field: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly operator: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                        };
-                                                        readonly value: {
-                                                            readonly oneOf: readonly [{
-                                                                readonly type: "boolean";
-                                                            }, {
-                                                                readonly type: "string";
-                                                            }, {
-                                                                readonly type: "number";
-                                                            }];
-                                                        };
-                                                        readonly modifier: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["not"];
-                                                        };
-                                                        readonly match: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly field: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly operator: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                    };
-                                                                    readonly value: {
-                                                                        readonly oneOf: readonly [{
-                                                                            readonly type: "boolean";
-                                                                        }, {
-                                                                            readonly type: "string";
-                                                                        }, {
-                                                                            readonly type: "number";
-                                                                        }];
-                                                                    };
-                                                                    readonly modifier: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["not"];
-                                                                    };
-                                                                };
-                                                            };
-                                                        };
-                                                    };
-                                                }, {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly operator: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["and", "or"];
-                                                        };
-                                                        readonly conditions: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly field: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly operator: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                    };
-                                                                    readonly value: {
-                                                                        readonly oneOf: readonly [{
-                                                                            readonly type: "boolean";
-                                                                        }, {
-                                                                            readonly type: "string";
-                                                                        }, {
-                                                                            readonly type: "number";
-                                                                        }];
-                                                                    };
-                                                                    readonly modifier: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["not"];
-                                                                    };
-                                                                    readonly match: {
-                                                                        readonly type: "array";
-                                                                        readonly items: {
-                                                                            readonly type: "object";
-                                                                            readonly properties: {
-                                                                                readonly field: {
-                                                                                    readonly type: "string";
-                                                                                };
-                                                                                readonly operator: {
-                                                                                    readonly type: "string";
-                                                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                                };
-                                                                                readonly value: {
-                                                                                    readonly oneOf: readonly [{
-                                                                                        readonly type: "boolean";
-                                                                                    }, {
-                                                                                        readonly type: "string";
-                                                                                    }, {
-                                                                                        readonly type: "number";
-                                                                                    }];
-                                                                                };
-                                                                                readonly modifier: {
-                                                                                    readonly type: "string";
-                                                                                    readonly enum: readonly ["not"];
-                                                                                };
-                                                                            };
-                                                                        };
-                                                                    };
-                                                                };
-                                                            };
-                                                        };
-                                                    };
-                                                    readonly required: readonly ["operator", "conditions"];
-                                                    readonly additionalProperties: false;
-                                                }];
-                                            };
-                                        };
-                                    };
-                                    readonly required: readonly ["operator", "conditions"];
-                                    readonly additionalProperties: false;
-                                }];
-                            };
-                        }, {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly operator: {
+                };
+                readonly levels: {
+                    readonly nodeTypeName: "ScorecardClassicLevelList";
+                    readonly description: "List of levels to score against.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly nodeTypeName: "ScorecardClassicLevel";
+                        readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#level-object";
+                        readonly type: "object";
+                        readonly required: readonly ["name"];
+                        readonly properties: {
+                            readonly extends: {
+                                readonly nodeTypeName: undefined;
+                                readonly type: "array";
+                                readonly items: {
                                     readonly type: "string";
-                                    readonly enum: readonly ["and", "or"];
-                                };
-                                readonly conditions: {
-                                    readonly type: "array";
-                                    readonly items: {
-                                        readonly oneOf: readonly [{
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly field: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly operator: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                };
-                                                readonly value: {
-                                                    readonly oneOf: readonly [{
-                                                        readonly type: "boolean";
-                                                    }, {
-                                                        readonly type: "string";
-                                                    }, {
-                                                        readonly type: "number";
-                                                    }];
-                                                };
-                                                readonly modifier: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["not"];
-                                                };
-                                                readonly match: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly field: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly operator: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                            };
-                                                            readonly value: {
-                                                                readonly oneOf: readonly [{
-                                                                    readonly type: "boolean";
-                                                                }, {
-                                                                    readonly type: "string";
-                                                                }, {
-                                                                    readonly type: "number";
-                                                                }];
-                                                            };
-                                                            readonly modifier: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["not"];
-                                                            };
-                                                        };
-                                                    };
-                                                };
-                                            };
-                                        }, {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly operator: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["and", "or"];
-                                                };
-                                                readonly conditions: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly oneOf: readonly [{
-                                                            readonly type: "object";
-                                                            readonly properties: {
-                                                                readonly field: {
-                                                                    readonly type: "string";
-                                                                };
-                                                                readonly operator: {
-                                                                    readonly type: "string";
-                                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                };
-                                                                readonly value: {
-                                                                    readonly oneOf: readonly [{
-                                                                        readonly type: "boolean";
-                                                                    }, {
-                                                                        readonly type: "string";
-                                                                    }, {
-                                                                        readonly type: "number";
-                                                                    }];
-                                                                };
-                                                                readonly modifier: {
-                                                                    readonly type: "string";
-                                                                    readonly enum: readonly ["not"];
-                                                                };
-                                                                readonly match: {
-                                                                    readonly type: "array";
-                                                                    readonly items: {
-                                                                        readonly type: "object";
-                                                                        readonly properties: {
-                                                                            readonly field: {
-                                                                                readonly type: "string";
-                                                                            };
-                                                                            readonly operator: {
-                                                                                readonly type: "string";
-                                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                            };
-                                                                            readonly value: {
-                                                                                readonly oneOf: readonly [{
-                                                                                    readonly type: "boolean";
-                                                                                }, {
-                                                                                    readonly type: "string";
-                                                                                }, {
-                                                                                    readonly type: "number";
-                                                                                }];
-                                                                            };
-                                                                            readonly modifier: {
-                                                                                readonly type: "string";
-                                                                                readonly enum: readonly ["not"];
-                                                                            };
-                                                                        };
-                                                                    };
-                                                                };
-                                                            };
-                                                        }, {
-                                                            readonly type: "object";
-                                                            readonly properties: {
-                                                                readonly operator: {
-                                                                    readonly type: "string";
-                                                                    readonly enum: readonly ["and", "or"];
-                                                                };
-                                                                readonly conditions: {
-                                                                    readonly type: "array";
-                                                                    readonly items: {
-                                                                        readonly type: "object";
-                                                                        readonly properties: {
-                                                                            readonly field: {
-                                                                                readonly type: "string";
-                                                                            };
-                                                                            readonly operator: {
-                                                                                readonly type: "string";
-                                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                            };
-                                                                            readonly value: {
-                                                                                readonly oneOf: readonly [{
-                                                                                    readonly type: "boolean";
-                                                                                }, {
-                                                                                    readonly type: "string";
-                                                                                }, {
-                                                                                    readonly type: "number";
-                                                                                }];
-                                                                            };
-                                                                            readonly modifier: {
-                                                                                readonly type: "string";
-                                                                                readonly enum: readonly ["not"];
-                                                                            };
-                                                                            readonly match: {
-                                                                                readonly type: "array";
-                                                                                readonly items: {
-                                                                                    readonly type: "object";
-                                                                                    readonly properties: {
-                                                                                        readonly field: {
-                                                                                            readonly type: "string";
-                                                                                        };
-                                                                                        readonly operator: {
-                                                                                            readonly type: "string";
-                                                                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
-                                                                                        };
-                                                                                        readonly value: {
-                                                                                            readonly oneOf: readonly [{
-                                                                                                readonly type: "boolean";
-                                                                                            }, {
-                                                                                                readonly type: "string";
-                                                                                            }, {
-                                                                                                readonly type: "number";
-                                                                                            }];
-                                                                                        };
-                                                                                        readonly modifier: {
-                                                                                            readonly type: "string";
-                                                                                            readonly enum: readonly ["not"];
-                                                                                        };
-                                                                                    };
-                                                                                };
-                                                                            };
-                                                                        };
-                                                                    };
-                                                                };
-                                                            };
-                                                            readonly required: readonly ["operator", "conditions"];
-                                                            readonly additionalProperties: false;
-                                                        }];
-                                                    };
-                                                };
-                                            };
-                                            readonly required: readonly ["operator", "conditions"];
-                                            readonly additionalProperties: false;
-                                        }];
-                                    };
                                 };
+                                readonly description: "Use extends to inherit rules and their configurations from other rulesets.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/extends";
                             };
-                            readonly required: readonly ["operator", "conditions"];
-                            readonly additionalProperties: false;
-                        }];
-                    };
-                    readonly levels: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly name: {
-                                    readonly type: "string";
-                                };
-                                readonly extends: {
-                                    readonly type: "array";
-                                    readonly items: {
-                                        readonly type: "string";
-                                    };
-                                };
-                                readonly rules: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: {
-                                        readonly oneOf: readonly [{
-                                            readonly type: "string";
-                                        }, {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly severity: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["error", "warn", "off"];
-                                                };
-                                                readonly weight: {
-                                                    readonly type: "number";
-                                                    readonly default: 1;
-                                                };
-                                            };
-                                            readonly additionalProperties: true;
-                                        }, {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly title: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly subject: {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
-                                                        };
-                                                        readonly property: {
-                                                            readonly type: "string";
-                                                        };
-                                                    };
-                                                    readonly required: readonly ["type", "property"];
-                                                    readonly additionalProperties: false;
-                                                };
-                                                readonly severity: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["error", "warn", "off"];
-                                                };
-                                                readonly message: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly assertions: {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly defined: {
-                                                            readonly type: "boolean";
-                                                        };
-                                                        readonly nonEmpty: {
-                                                            readonly type: "boolean";
-                                                        };
-                                                        readonly eq: {};
-                                                        readonly gt: {
-                                                            readonly type: "number";
-                                                        };
-                                                        readonly gte: {
-                                                            readonly type: "number";
-                                                        };
-                                                        readonly lt: {
-                                                            readonly type: "number";
-                                                        };
-                                                        readonly lte: {
-                                                            readonly type: "number";
-                                                        };
-                                                        readonly const: {};
-                                                    };
-                                                    readonly additionalProperties: false;
-                                                };
-                                                readonly where: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly subject: {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly type: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
-                                                                    };
-                                                                    readonly property: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                };
-                                                                readonly required: readonly ["type", "property"];
-                                                                readonly additionalProperties: false;
-                                                            };
-                                                            readonly assertions: {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly defined: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly nonEmpty: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly eq: {};
-                                                                    readonly gt: {
-                                                                        readonly type: "number";
-                                                                    };
-                                                                    readonly gte: {
-                                                                        readonly type: "number";
-                                                                    };
-                                                                    readonly lt: {
-                                                                        readonly type: "number";
-                                                                    };
-                                                                    readonly lte: {
-                                                                        readonly type: "number";
-                                                                    };
-                                                                    readonly const: {};
-                                                                };
-                                                                readonly additionalProperties: false;
-                                                            };
-                                                        };
-                                                        readonly required: readonly ["subject", "assertions"];
-                                                        readonly additionalProperties: false;
-                                                    };
-                                                };
-                                                readonly weight: {
-                                                    readonly type: "number";
-                                                    readonly default: 1;
-                                                };
-                                            };
-                                            readonly required: readonly ["subject", "assertions"];
-                                            readonly additionalProperties: false;
-                                        }];
-                                    };
-                                };
-                            };
-                            readonly required: readonly ["name"];
-                            readonly additionalProperties: false;
-                        };
-                        readonly minItems: 1;
-                    };
-                    readonly trigger: {
-                        readonly oneOf: readonly [{
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly event: {
-                                    readonly type: "string";
-                                    readonly enum: readonly ["runtime", "manual"];
-                                };
-                            };
-                            readonly required: readonly ["event"];
-                            readonly additionalProperties: false;
-                        }, {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly event: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["runtime", "manual"];
-                                    };
-                                };
-                                readonly required: readonly ["event"];
-                                readonly additionalProperties: false;
-                            };
-                        }];
-                    };
-                };
-                readonly required: readonly ["name", "key", "entities", "levels"];
-                readonly additionalProperties: false;
-            };
-        };
-        readonly scorecardClassic: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-            readonly required: readonly [];
-            readonly properties: {
-                readonly ignoreNonCompliant: {
-                    readonly type: "boolean";
-                    readonly default: false;
-                };
-                readonly teamMetadataProperty: {
-                    readonly type: "object";
-                    readonly properties: {
-                        readonly property: {
-                            readonly type: "string";
-                        };
-                        readonly label: {
-                            readonly type: "string";
-                        };
-                        readonly default: {
-                            readonly type: "string";
-                        };
-                    };
-                };
-                readonly levels: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly required: readonly ["name"];
-                        readonly properties: {
-                            readonly decorators: {
+                            readonly preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas2Decorators: {
+                            readonly oas2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_0Decorators: {
+                            readonly oas3_0Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_1Decorators: {
+                            readonly oas3_1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_2Decorators: {
+                            readonly oas3_2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async2Decorators: {
+                            readonly async2Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async3Decorators: {
+                            readonly async3Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly arazzo1Decorators: {
+                            readonly arazzo1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly overlay1Decorators: {
+                            readonly overlay1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly openrpc1Decorators: {
+                            readonly openrpc1Preprocessors: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly preprocessors: {
+                            readonly decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas2Preprocessors: {
+                            readonly oas2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_0Preprocessors: {
+                            readonly oas3_0Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_1Preprocessors: {
+                            readonly oas3_1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly oas3_2Preprocessors: {
+                            readonly oas3_2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async2Preprocessors: {
+                            readonly async2Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly async3Preprocessors: {
+                            readonly async3Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly arazzo1Preprocessors: {
+                            readonly arazzo1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly overlay1Preprocessors: {
+                            readonly overlay1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
-                            readonly openrpc1Preprocessors: {
+                            readonly openrpc1Decorators: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
                             readonly rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6317,8 +5835,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6327,8 +5848,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_0Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6337,8 +5861,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6347,8 +5874,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly oas3_2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6357,8 +5887,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly async2Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6367,8 +5900,11 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly async3Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6377,8 +5913,37 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
                             };
                             readonly arazzo1Rules: {
+                                readonly nodeTypeName: undefined;
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
+                            };
+                            readonly overlay1Rules: {
+                                readonly nodeTypeName: undefined;
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
+                            };
+                            readonly openrpc1Rules: {
+                                readonly nodeTypeName: undefined;
                                 readonly type: "object";
                                 readonly additionalProperties: {
                                     readonly oneOf: readonly [{
@@ -6387,83 +5952,661 @@ export declare const themeConfigSchema: {
                                         readonly type: "object";
                                     }];
                                 };
+                                readonly description: "The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.";
+                                readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/rules#rules";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly color: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly targets: {
+                    readonly nodeTypeName: "ScorecardClassicTargetList";
+                    readonly description: "Provide custom `minimumLevel` for specific targets.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly nodeTypeName: "ScorecardClassicTarget";
+                        readonly type: "object";
+                        readonly required: readonly ["where"];
+                        readonly properties: {
+                            readonly minimumLevel: {
+                                readonly type: "string";
+                            };
+                            readonly rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly where: {
+                                readonly nodeTypeName: "ScorecardClassicTargetWhere";
+                                readonly description: "Specify which API descriptions to apply the `minimumLevel` to based on the metadata.";
+                                readonly documentationLink: "https://redocly.com/docs/realm/config/scorecard-classic#where-object";
+                                readonly type: "object";
+                                readonly required: readonly ["metadata"];
+                                readonly properties: {
+                                    readonly metadata: {
+                                        readonly nodeTypeName: "ScorecardClassicTargetWhereMetadata";
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly ignore: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly fromProjectUrl: {
+                    readonly type: "string";
+                    readonly format: "uri";
+                };
+            };
+        };
+        readonly scorecards: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly entities: {
+                        readonly oneOf: readonly [{
+                            readonly type: "array";
+                            readonly items: {
+                                readonly oneOf: readonly [{
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly field: {
+                                            readonly type: "string";
+                                        };
+                                        readonly operator: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                        };
+                                        readonly value: {
+                                            readonly oneOf: readonly [{
+                                                readonly type: "boolean";
+                                            }, {
+                                                readonly type: "string";
+                                            }, {
+                                                readonly type: "number";
+                                            }];
+                                        };
+                                        readonly modifier: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["not"];
+                                        };
+                                        readonly match: {
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly properties: {
+                                                    readonly field: {
+                                                        readonly type: "string";
+                                                    };
+                                                    readonly operator: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "boolean";
+                                                        }, {
+                                                            readonly type: "string";
+                                                        }, {
+                                                            readonly type: "number";
+                                                        }];
+                                                    };
+                                                    readonly modifier: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["not"];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                }, {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly operator: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["and", "or"];
+                                        };
+                                        readonly conditions: {
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly oneOf: readonly [{
+                                                    readonly type: "object";
+                                                    readonly properties: {
+                                                        readonly field: {
+                                                            readonly type: "string";
+                                                        };
+                                                        readonly operator: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                        };
+                                                        readonly value: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly type: "boolean";
+                                                            }, {
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "number";
+                                                            }];
+                                                        };
+                                                        readonly modifier: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["not"];
+                                                        };
+                                                        readonly match: {
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly properties: {
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                    readonly operator: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                    };
+                                                                    readonly value: {
+                                                                        readonly oneOf: readonly [{
+                                                                            readonly type: "boolean";
+                                                                        }, {
+                                                                            readonly type: "string";
+                                                                        }, {
+                                                                            readonly type: "number";
+                                                                        }];
+                                                                    };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: "object";
+                                                    readonly properties: {
+                                                        readonly operator: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["and", "or"];
+                                                        };
+                                                        readonly conditions: {
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "object";
+                                                                readonly properties: {
+                                                                    readonly field: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                    readonly operator: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                    };
+                                                                    readonly value: {
+                                                                        readonly oneOf: readonly [{
+                                                                            readonly type: "boolean";
+                                                                        }, {
+                                                                            readonly type: "string";
+                                                                        }, {
+                                                                            readonly type: "number";
+                                                                        }];
+                                                                    };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
+                                                                    readonly match: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "object";
+                                                                            readonly properties: {
+                                                                                readonly field: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly operator: {
+                                                                                    readonly type: "string";
+                                                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                                };
+                                                                                readonly value: {
+                                                                                    readonly oneOf: readonly [{
+                                                                                        readonly type: "boolean";
+                                                                                    }, {
+                                                                                        readonly type: "string";
+                                                                                    }, {
+                                                                                        readonly type: "number";
+                                                                                    }];
+                                                                                };
+                                                                                readonly modifier: {
+                                                                                    readonly type: "string";
+                                                                                    readonly enum: readonly ["not"];
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly required: readonly ["operator", "conditions"];
+                                                    readonly additionalProperties: false;
+                                                }];
+                                            };
+                                        };
+                                    };
+                                    readonly required: readonly ["operator", "conditions"];
+                                    readonly additionalProperties: false;
+                                }];
+                            };
+                        }, {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly operator: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["and", "or"];
+                                };
+                                readonly conditions: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly field: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly operator: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                };
+                                                readonly value: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly type: "boolean";
+                                                    }, {
+                                                        readonly type: "string";
+                                                    }, {
+                                                        readonly type: "number";
+                                                    }];
+                                                };
+                                                readonly modifier: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["not"];
+                                                };
+                                                readonly match: {
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly type: "object";
+                                                        readonly properties: {
+                                                            readonly field: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly operator: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                            };
+                                                            readonly value: {
+                                                                readonly oneOf: readonly [{
+                                                                    readonly type: "boolean";
+                                                                }, {
+                                                                    readonly type: "string";
+                                                                }, {
+                                                                    readonly type: "number";
+                                                                }];
+                                                            };
+                                                            readonly modifier: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["not"];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly operator: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["and", "or"];
+                                                };
+                                                readonly conditions: {
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "object";
+                                                            readonly properties: {
+                                                                readonly field: {
+                                                                    readonly type: "string";
+                                                                };
+                                                                readonly operator: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly oneOf: readonly [{
+                                                                        readonly type: "boolean";
+                                                                    }, {
+                                                                        readonly type: "string";
+                                                                    }, {
+                                                                        readonly type: "number";
+                                                                    }];
+                                                                };
+                                                                readonly modifier: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["not"];
+                                                                };
+                                                                readonly match: {
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly properties: {
+                                                                            readonly field: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly operator: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                            };
+                                                                            readonly value: {
+                                                                                readonly oneOf: readonly [{
+                                                                                    readonly type: "boolean";
+                                                                                }, {
+                                                                                    readonly type: "string";
+                                                                                }, {
+                                                                                    readonly type: "number";
+                                                                                }];
+                                                                            };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly type: "object";
+                                                            readonly properties: {
+                                                                readonly operator: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["and", "or"];
+                                                                };
+                                                                readonly conditions: {
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly properties: {
+                                                                            readonly field: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly operator: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                            };
+                                                                            readonly value: {
+                                                                                readonly oneOf: readonly [{
+                                                                                    readonly type: "boolean";
+                                                                                }, {
+                                                                                    readonly type: "string";
+                                                                                }, {
+                                                                                    readonly type: "number";
+                                                                                }];
+                                                                            };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
+                                                                            readonly match: {
+                                                                                readonly type: "array";
+                                                                                readonly items: {
+                                                                                    readonly type: "object";
+                                                                                    readonly properties: {
+                                                                                        readonly field: {
+                                                                                            readonly type: "string";
+                                                                                        };
+                                                                                        readonly operator: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
+                                                                                        };
+                                                                                        readonly value: {
+                                                                                            readonly oneOf: readonly [{
+                                                                                                readonly type: "boolean";
+                                                                                            }, {
+                                                                                                readonly type: "string";
+                                                                                            }, {
+                                                                                                readonly type: "number";
+                                                                                            }];
+                                                                                        };
+                                                                                        readonly modifier: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["not"];
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly required: readonly ["operator", "conditions"];
+                                                            readonly additionalProperties: false;
+                                                        }];
+                                                    };
+                                                };
+                                            };
+                                            readonly required: readonly ["operator", "conditions"];
+                                            readonly additionalProperties: false;
+                                        }];
+                                    };
+                                };
                             };
-                            readonly overlay1Rules: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly oneOf: readonly [{
-                                        readonly type: "string";
-                                    }, {
-                                        readonly type: "object";
-                                    }];
+                            readonly required: readonly ["operator", "conditions"];
+                            readonly additionalProperties: false;
+                        }];
+                    };
+                    readonly levels: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
                                 };
-                            };
-                            readonly openrpc1Rules: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly oneOf: readonly [{
+                                readonly extends: {
+                                    readonly nodeTypeName: undefined;
+                                    readonly type: "array";
+                                    readonly items: {
                                         readonly type: "string";
-                                    }, {
-                                        readonly type: "object";
-                                    }];
+                                    };
+                                    readonly description: "Use extends to inherit rules and their configurations from other rulesets.";
+                                    readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/extends";
                                 };
-                            };
-                            readonly name: {
-                                readonly type: "string";
-                            };
-                            readonly color: {
-                                readonly type: "string";
-                            };
-                            readonly extends: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
+                                readonly rules: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "string";
+                                        }, {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly severity: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["error", "warn", "off"];
+                                                };
+                                                readonly weight: {
+                                                    readonly type: "number";
+                                                    readonly default: 1;
+                                                };
+                                            };
+                                            readonly additionalProperties: true;
+                                        }, {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly title: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly subject: {
+                                                    readonly type: "object";
+                                                    readonly properties: {
+                                                        readonly type: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
+                                                        };
+                                                        readonly property: {
+                                                            readonly type: "string";
+                                                        };
+                                                    };
+                                                    readonly required: readonly ["type", "property"];
+                                                    readonly additionalProperties: false;
+                                                };
+                                                readonly severity: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["error", "warn", "off"];
+                                                };
+                                                readonly message: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly assertions: {
+                                                    readonly type: "object";
+                                                    readonly properties: {
+                                                        readonly defined: {
+                                                            readonly type: "boolean";
+                                                        };
+                                                        readonly nonEmpty: {
+                                                            readonly type: "boolean";
+                                                        };
+                                                        readonly eq: {};
+                                                        readonly gt: {
+                                                            readonly type: "number";
+                                                        };
+                                                        readonly gte: {
+                                                            readonly type: "number";
+                                                        };
+                                                        readonly lt: {
+                                                            readonly type: "number";
+                                                        };
+                                                        readonly lte: {
+                                                            readonly type: "number";
+                                                        };
+                                                        readonly const: {};
+                                                    };
+                                                    readonly additionalProperties: false;
+                                                };
+                                                readonly where: {
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly type: "object";
+                                                        readonly properties: {
+                                                            readonly subject: {
+                                                                readonly type: "object";
+                                                                readonly properties: {
+                                                                    readonly type: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
+                                                                    };
+                                                                    readonly property: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                                readonly required: readonly ["type", "property"];
+                                                                readonly additionalProperties: false;
+                                                            };
+                                                            readonly assertions: {
+                                                                readonly type: "object";
+                                                                readonly properties: {
+                                                                    readonly defined: {
+                                                                        readonly type: "boolean";
+                                                                    };
+                                                                    readonly nonEmpty: {
+                                                                        readonly type: "boolean";
+                                                                    };
+                                                                    readonly eq: {};
+                                                                    readonly gt: {
+                                                                        readonly type: "number";
+                                                                    };
+                                                                    readonly gte: {
+                                                                        readonly type: "number";
+                                                                    };
+                                                                    readonly lt: {
+                                                                        readonly type: "number";
+                                                                    };
+                                                                    readonly lte: {
+                                                                        readonly type: "number";
+                                                                    };
+                                                                    readonly const: {};
+                                                                };
+                                                                readonly additionalProperties: false;
+                                                            };
+                                                        };
+                                                        readonly required: readonly ["subject", "assertions"];
+                                                        readonly additionalProperties: false;
+                                                    };
+                                                };
+                                                readonly weight: {
+                                                    readonly type: "number";
+                                                    readonly default: 1;
+                                                };
+                                            };
+                                            readonly required: readonly ["subject", "assertions"];
+                                            readonly additionalProperties: false;
+                                        }];
+                                    };
                                 };
                             };
+                            readonly required: readonly ["name"];
+                            readonly additionalProperties: false;
                         };
-                        readonly additionalProperties: false;
+                        readonly minItems: 1;
                     };
-                };
-                readonly targets: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly required: readonly ["where"];
-                        readonly properties: {
-                            readonly minimumLevel: {
-                                readonly type: "string";
-                            };
-                            readonly rules: {
-                                readonly type: "object";
-                                readonly additionalProperties: true;
+                    readonly trigger: {
+                        readonly oneOf: readonly [{
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly event: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["runtime", "manual"];
+                                };
                             };
-                            readonly where: {
+                            readonly required: readonly ["event"];
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "array";
+                            readonly items: {
                                 readonly type: "object";
-                                readonly required: readonly ["metadata"];
                                 readonly properties: {
-                                    readonly metadata: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
-                                        };
+                                    readonly event: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["runtime", "manual"];
                                     };
                                 };
+                                readonly required: readonly ["event"];
                                 readonly additionalProperties: false;
                             };
-                        };
-                        readonly additionalProperties: false;
-                    };
-                };
-                readonly ignore: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
+                        }];
                     };
                 };
-                readonly fromProjectUrl: {
-                    readonly type: "string";
-                    readonly format: "uri";
-                };
+                readonly required: readonly ["name", "key", "entities", "levels"];
+                readonly additionalProperties: false;
             };
         };
     };