@redocly/config 0.39.0 → 0.41.0

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

@@ -3457,6 +3457,58 @@ export declare const themeConfigSchema: {
                 readonly showBuiltInDirectives: {
                     readonly type: "boolean";
                 };
+                readonly info: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly title: {
+                            readonly type: "string";
+                        };
+                        readonly version: {
+                            readonly type: "string";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                        };
+                        readonly termsOfService: {
+                            readonly type: "string";
+                            readonly format: "uri";
+                        };
+                        readonly contact: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                };
+                                readonly url: {
+                                    readonly type: "string";
+                                    readonly format: "uri";
+                                };
+                                readonly email: {
+                                    readonly type: "string";
+                                    readonly format: "email";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly license: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                };
+                                readonly url: {
+                                    readonly type: "string";
+                                    readonly format: "uri";
+                                };
+                                readonly identifier: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
             };
             readonly additionalProperties: false;
         };
@@ -5285,6 +5337,9 @@ export declare const themeConfigSchema: {
                 };
             };
         };
+        /**
+         * @deprecated Should use `scorecardClassic` instead
+         */
         readonly scorecard: {
             readonly type: "object";
             readonly additionalProperties: true;
@@ -5535,13 +5590,792 @@ export declare const themeConfigSchema: {
             };
         };
         readonly scorecards: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly name: {
+                        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", "and", "or", "not"];
+                                        };
+                                        readonly value: {
+                                            readonly oneOf: readonly [{
+                                                readonly type: "boolean";
+                                            }, {
+                                                readonly type: "string";
+                                            }, {
+                                                readonly type: "number";
+                                            }];
+                                        };
+                                        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", "and", "or", "not"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "boolean";
+                                                        }, {
+                                                            readonly type: "string";
+                                                        }, {
+                                                            readonly type: "number";
+                                                        }];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                }, {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly operator: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none", "and", "or", "not"];
+                                        };
+                                        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", "and", "or", "not"];
+                                                        };
+                                                        readonly value: {
+                                                            readonly oneOf: readonly [{
+                                                                readonly type: "boolean";
+                                                            }, {
+                                                                readonly type: "string";
+                                                            }, {
+                                                                readonly type: "number";
+                                                            }];
+                                                        };
+                                                        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", "and", "or", "not"];
+                                                                    };
+                                                                    readonly value: {
+                                                                        readonly oneOf: readonly [{
+                                                                            readonly type: "boolean";
+                                                                        }, {
+                                                                            readonly type: "string";
+                                                                        }, {
+                                                                            readonly type: "number";
+                                                                        }];
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                }, {
+                                                    readonly type: "object";
+                                                    readonly properties: {
+                                                        readonly operator: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none", "and", "or", "not"];
+                                                        };
+                                                        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", "and", "or", "not"];
+                                                                    };
+                                                                    readonly value: {
+                                                                        readonly oneOf: readonly [{
+                                                                            readonly type: "boolean";
+                                                                        }, {
+                                                                            readonly type: "string";
+                                                                        }, {
+                                                                            readonly type: "number";
+                                                                        }];
+                                                                    };
+                                                                    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", "and", "or", "not"];
+                                                                                };
+                                                                                readonly value: {
+                                                                                    readonly oneOf: readonly [{
+                                                                                        readonly type: "boolean";
+                                                                                    }, {
+                                                                                        readonly type: "string";
+                                                                                    }, {
+                                                                                        readonly type: "number";
+                                                                                    }];
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    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 ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none", "and", "or", "not"];
+                                };
+                                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", "and", "or", "not"];
+                                                };
+                                                readonly value: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly type: "boolean";
+                                                    }, {
+                                                        readonly type: "string";
+                                                    }, {
+                                                        readonly type: "number";
+                                                    }];
+                                                };
+                                                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", "and", "or", "not"];
+                                                            };
+                                                            readonly value: {
+                                                                readonly oneOf: readonly [{
+                                                                    readonly type: "boolean";
+                                                                }, {
+                                                                    readonly type: "string";
+                                                                }, {
+                                                                    readonly type: "number";
+                                                                }];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        }, {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly operator: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none", "and", "or", "not"];
+                                                };
+                                                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", "and", "or", "not"];
+                                                                };
+                                                                readonly value: {
+                                                                    readonly oneOf: readonly [{
+                                                                        readonly type: "boolean";
+                                                                    }, {
+                                                                        readonly type: "string";
+                                                                    }, {
+                                                                        readonly type: "number";
+                                                                    }];
+                                                                };
+                                                                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", "and", "or", "not"];
+                                                                            };
+                                                                            readonly value: {
+                                                                                readonly oneOf: readonly [{
+                                                                                    readonly type: "boolean";
+                                                                                }, {
+                                                                                    readonly type: "string";
+                                                                                }, {
+                                                                                    readonly type: "number";
+                                                                                }];
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly type: "object";
+                                                            readonly properties: {
+                                                                readonly operator: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none", "and", "or", "not"];
+                                                                };
+                                                                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", "and", "or", "not"];
+                                                                            };
+                                                                            readonly value: {
+                                                                                readonly oneOf: readonly [{
+                                                                                    readonly type: "boolean";
+                                                                                }, {
+                                                                                    readonly type: "string";
+                                                                                }, {
+                                                                                    readonly type: "number";
+                                                                                }];
+                                                                            };
+                                                                            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", "and", "or", "not"];
+                                                                                        };
+                                                                                        readonly value: {
+                                                                                            readonly oneOf: readonly [{
+                                                                                                readonly type: "boolean";
+                                                                                            }, {
+                                                                                                readonly type: "string";
+                                                                                            }, {
+                                                                                                readonly type: "number";
+                                                                                            }];
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly required: readonly ["operator", "conditions"];
+                                                            readonly additionalProperties: false;
+                                                        }];
+                                                    };
+                                                };
+                                            };
+                                            readonly required: readonly ["operator", "conditions"];
+                                            readonly additionalProperties: false;
+                                        }];
+                                    };
+                                };
+                            };
+                            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", "entities", "levels"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly scorecardClassic: {
             readonly type: "object";
             readonly additionalProperties: true;
             readonly required: readonly [];
             readonly properties: {
-                readonly test: {
+                readonly ignoreNonCompliant: {
                     readonly type: "boolean";
-                    readonly default: true;
+                    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 type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas2Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_0Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_1Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_2Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly async2Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly async3Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly arazzo1Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly overlay1Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas2Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_0Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_1Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly oas3_2Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly async2Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly async3Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly arazzo1Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly overlay1Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                            readonly rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly oas2Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly oas3_0Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly oas3_1Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly oas3_2Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly async2Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly async3Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly arazzo1Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly overlay1Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly color: {
+                                readonly type: "string";
+                            };
+                            readonly extends: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                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 where: {
+                                readonly type: "object";
+                                readonly required: readonly ["metadata"];
+                                readonly properties: {
+                                    readonly metadata: {
+                                        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";
                 };
             };
         };