@redocly/config 0.40.0 → 0.41.1

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

@@ -5405,6 +5405,10 @@ export declare const themeConfigSchema: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
+                            readonly openrpc1Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
                             readonly preprocessors: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
@@ -5441,6 +5445,10 @@ export declare const themeConfigSchema: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
+                            readonly openrpc1Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
                             readonly rules: {
                                 readonly type: "object";
                                 readonly additionalProperties: {
@@ -5531,6 +5539,16 @@ export declare const themeConfigSchema: {
                                     }];
                                 };
                             };
+                            readonly openrpc1Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
                             readonly name: {
                                 readonly type: "string";
                             };
@@ -5590,14 +5608,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: {
@@ -5665,6 +6213,10 @@ export declare const themeConfigSchema: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
+                            readonly openrpc1Decorators: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
                             readonly preprocessors: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
@@ -5701,6 +6253,10 @@ export declare const themeConfigSchema: {
                                 readonly type: "object";
                                 readonly additionalProperties: true;
                             };
+                            readonly openrpc1Preprocessors: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
                             readonly rules: {
                                 readonly type: "object";
                                 readonly additionalProperties: {
@@ -5791,6 +6347,16 @@ export declare const themeConfigSchema: {
                                     }];
                                 };
                             };
+                            readonly openrpc1Rules: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "string";
+                                    }, {
+                                        readonly type: "object";
+                                    }];
+                                };
+                            };
                             readonly name: {
                                 readonly type: "string";
                             };