@redocly/config 0.40.0 → 0.41.0

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

@@ -5590,14 +5590,544 @@ export declare const themeConfigSchema: {
             };
         };
         readonly scorecards: {
-            readonly type: "object";
-            readonly additionalProperties: true;
-            readonly required: readonly [];
-            readonly properties: {
-                readonly test: {
-                    readonly type: "boolean";
-                    readonly default: true;
+            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: {

package/lib/default-theme-config-schema.js

@@ -5,6 +5,7 @@ const graphql_config_schema_1 = require("./graphql-config-schema");
 const feedback_config_schema_1 = require("./feedback-config-schema");
 const ex_theme_config_schemas_1 = require("./ex-theme-config-schemas");
 const entities_catalog_config_schema_1 = require("./entities-catalog-config-schema");
+const scorecards_config_schema_1 = require("./scorecards-config-schema");
 exports.themeConfigSchema = {
     type: 'object',
     properties: {
@@ -45,7 +46,7 @@ exports.themeConfigSchema = {
          * @deprecated Should use `scorecardClassic` instead
          */
         scorecard: ex_theme_config_schemas_1.scorecardConfigSchema,
-        scorecards: ex_theme_config_schemas_1.scorecardsConfigSchema,
+        scorecards: scorecards_config_schema_1.scorecardsConfigSchema,
         scorecardClassic: ex_theme_config_schemas_1.scorecardConfigSchema,
     },
     additionalProperties: true,

package/lib/ex-theme-config-schemas.d.ts

@@ -4453,14 +4453,3 @@ export declare const scorecardConfigSchema: {
         };
     };
 };
-export declare const scorecardsConfigSchema: {
-    readonly type: "object";
-    readonly additionalProperties: true;
-    readonly required: readonly [];
-    readonly properties: {
-        readonly test: {
-            readonly type: "boolean";
-            readonly default: true;
-        };
-    };
-};

package/lib/ex-theme-config-schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scorecardsConfigSchema = exports.scorecardConfigSchema = exports.catalogsConfigSchema = exports.catalogSchema = exports.catalogFilterSchema = exports.breadcrumbsConfigSchema = exports.versionPickerConfigSchema = exports.userMenuConfigSchema = exports.analyticsConfigSchema = exports.googleAnalyticsConfigSchema = exports.productGoogleAnalyticsConfigSchema = exports.gtmAnalyticsConfigSchema = exports.segmentAnalyticsConfigSchema = exports.rudderstackAnalyticsConfigSchema = exports.heapAnalyticsConfigSchema = exports.fullstoryAnalyticsConfigSchema = exports.amplitudeAnalyticsConfigSchema = exports.openapiConfigSchema = exports.markdownConfigSchema = exports.codeSnippetConfigSchema = exports.navigationConfigSchema = exports.colorModeConfigSchema = exports.aiAssistantSchema = exports.searchConfigSchema = exports.linksConfigSchema = exports.scriptsConfigSchema = exports.sidebarConfigSchema = exports.footerConfigSchema = exports.productsConfigSchema = exports.navbarConfigSchema = exports.logoConfigSchema = exports.searchFiltersConfigSchema = exports.searchFacetsConfigSchema = exports.aiSearchConfigSchema = exports.productConfigSchema = exports.navItemsSchema = void 0;
+exports.scorecardConfigSchema = exports.catalogsConfigSchema = exports.catalogSchema = exports.catalogFilterSchema = exports.breadcrumbsConfigSchema = exports.versionPickerConfigSchema = exports.userMenuConfigSchema = exports.analyticsConfigSchema = exports.googleAnalyticsConfigSchema = exports.productGoogleAnalyticsConfigSchema = exports.gtmAnalyticsConfigSchema = exports.segmentAnalyticsConfigSchema = exports.rudderstackAnalyticsConfigSchema = exports.heapAnalyticsConfigSchema = exports.fullstoryAnalyticsConfigSchema = exports.amplitudeAnalyticsConfigSchema = exports.openapiConfigSchema = exports.markdownConfigSchema = exports.codeSnippetConfigSchema = exports.navigationConfigSchema = exports.colorModeConfigSchema = exports.aiAssistantSchema = exports.searchConfigSchema = exports.linksConfigSchema = exports.scriptsConfigSchema = exports.sidebarConfigSchema = exports.footerConfigSchema = exports.productsConfigSchema = exports.navbarConfigSchema = exports.logoConfigSchema = exports.searchFiltersConfigSchema = exports.searchFacetsConfigSchema = exports.aiSearchConfigSchema = exports.productConfigSchema = exports.navItemsSchema = void 0;
 const redoc_config_schema_1 = require("./redoc-config-schema");
 const reference_docs_config_schema_1 = require("./reference-docs-config-schema");
 const common_1 = require("./common");
@@ -658,12 +658,4 @@ exports.scorecardConfigSchema = {
         fromProjectUrl: { type: 'string', format: 'uri' },
     },
 };
-exports.scorecardsConfigSchema = {
-    type: 'object',
-    additionalProperties: true,
-    required: [],
-    properties: {
-        test: { type: 'boolean', default: true },
-    },
-};
 //# sourceMappingURL=ex-theme-config-schemas.js.map