@redocly/config 0.41.3 → 0.42.0

package/lib-esm/root-config-schema.d.ts

@@ -500,6 +500,12 @@ export declare const bannerColorSchema: {
     readonly enum: readonly ["info", "success", "warning", "error"];
     readonly default: "info";
 };
+export declare const rbacScopeItemsSchema: {
+    readonly type: "object";
+    readonly additionalProperties: {
+        readonly type: "string";
+    };
+};
 export declare const bannerConfigSchema: {
     readonly type: "object";
     readonly properties: {
@@ -518,6 +524,12 @@ export declare const bannerConfigSchema: {
             readonly enum: readonly ["info", "success", "warning", "error"];
             readonly default: "info";
         };
+        readonly rbac: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
     };
     readonly required: readonly ["content"];
     readonly additionalProperties: false;
@@ -542,6 +554,12 @@ export declare const bannersConfigSchema: {
                 readonly enum: readonly ["info", "success", "warning", "error"];
                 readonly default: "info";
             };
+            readonly rbac: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
         };
         readonly required: readonly ["content"];
         readonly additionalProperties: false;
@@ -5539,11 +5557,161 @@ export declare const apiFunctionsConfigSchema: {
     };
     readonly additionalProperties: false;
 };
-export declare const rbacScopeItemsSchema: {
+export declare const rbacEntitiesCatalogConfigSchema: {
     readonly type: "object";
-    readonly additionalProperties: {
-        readonly type: "string";
+    readonly properties: {
+        readonly catalogs: {
+            readonly type: "object";
+            readonly properties: {
+                readonly all: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly services: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly domains: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly teams: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly users: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly apiDescriptions: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly dataSchemas: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly apiOperations: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly entitiesTypes: {
+            readonly type: "object";
+            readonly properties: {
+                readonly service: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly domain: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly team: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly user: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly apiDescription: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly apiOperation: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+                readonly dataSchema: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly entitiesGroups: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly entities: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly config: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly entities: {
+            readonly type: "object";
+            readonly properties: {
+                readonly '**': {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+            };
+        };
     };
+    readonly additionalProperties: false;
 };
 export declare const rbacConfigSchema: {
     readonly type: "object";
@@ -5607,6 +5775,162 @@ export declare const rbacConfigSchema: {
                 };
             };
         };
+        readonly entitiesCatalog: {
+            readonly type: "object";
+            readonly properties: {
+                readonly catalogs: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly all: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly services: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly domains: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly teams: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly users: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly apiDescriptions: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly dataSchemas: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly apiOperations: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly entitiesTypes: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly service: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly domain: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly team: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly user: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly apiDescription: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly apiOperation: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly dataSchema: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly entitiesGroups: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly entities: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly config: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly entities: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly '**': {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
     };
     readonly additionalProperties: {
         readonly type: "object";
@@ -6174,6 +6498,162 @@ export declare const accessConfigSchema: {
                         };
                     };
                 };
+                readonly entitiesCatalog: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly catalogs: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly all: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly services: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domains: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly teams: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly users: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescriptions: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchemas: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperations: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesTypes: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly service: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domain: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly team: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly user: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescription: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperation: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchema: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesGroups: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly entities: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly config: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly entities: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly '**': {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
             };
             readonly additionalProperties: {
                 readonly type: "object";
@@ -6446,6 +6926,162 @@ export declare const redoclyConfigSchema: {
                                 };
                             };
                         };
+                        readonly entitiesCatalog: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly catalogs: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly all: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly services: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly domains: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly teams: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly users: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiDescriptions: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly dataSchemas: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiOperations: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly entitiesTypes: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly service: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly domain: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly team: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly user: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiDescription: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiOperation: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly dataSchema: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly entitiesGroups: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly properties: {
+                                            readonly entities: {
+                                                readonly type: "array";
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                            readonly config: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    };
+                                };
+                                readonly entities: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly '**': {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
                     };
                     readonly additionalProperties: {
                         readonly type: "object";
@@ -12362,7 +12998,7 @@ export declare const redoclyConfigSchema: {
                                                 };
                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                 };
                                                 readonly value: {
                                                     readonly oneOf: readonly [{
@@ -12373,6 +13009,10 @@ export declare const redoclyConfigSchema: {
                                                         readonly type: "number";
                                                     }];
                                                 };
+                                                readonly modifier: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["not"];
+                                                };
                                                 readonly match: {
                                                     readonly type: "array";
                                                     readonly items: {
@@ -12383,7 +13023,7 @@ export declare const redoclyConfigSchema: {
                                                             };
                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                             };
                                                             readonly value: {
                                                                 readonly oneOf: readonly [{
@@ -12394,6 +13034,10 @@ export declare const redoclyConfigSchema: {
                                                                     readonly type: "number";
                                                                 }];
                                                             };
+                                                            readonly modifier: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["not"];
+                                                            };
                                                         };
                                                     };
                                                 };
@@ -12403,7 +13047,7 @@ export declare const redoclyConfigSchema: {
                                             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 enum: readonly ["and", "or"];
                                                 };
                                                 readonly conditions: {
                                                     readonly type: "array";
@@ -12416,7 +13060,7 @@ export declare const redoclyConfigSchema: {
                                                                 };
                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                 };
                                                                 readonly value: {
                                                                     readonly oneOf: readonly [{
@@ -12427,6 +13071,10 @@ export declare const redoclyConfigSchema: {
                                                                         readonly type: "number";
                                                                     }];
                                                                 };
+                                                                readonly modifier: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["not"];
+                                                                };
                                                                 readonly match: {
                                                                     readonly type: "array";
                                                                     readonly items: {
@@ -12437,7 +13085,7 @@ export declare const redoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -12448,6 +13096,10 @@ export declare const redoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                         };
                                                                     };
                                                                 };
@@ -12457,7 +13109,7 @@ export declare const redoclyConfigSchema: {
                                                             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 enum: readonly ["and", "or"];
                                                                 };
                                                                 readonly conditions: {
                                                                     readonly type: "array";
@@ -12469,7 +13121,7 @@ export declare const redoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -12480,6 +13132,10 @@ export declare const redoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                             readonly match: {
                                                                                 readonly type: "array";
                                                                                 readonly items: {
@@ -12490,7 +13146,7 @@ export declare const redoclyConfigSchema: {
                                                                                         };
                                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                         };
                                                                                         readonly value: {
                                                                                             readonly oneOf: readonly [{
@@ -12501,6 +13157,10 @@ export declare const redoclyConfigSchema: {
                                                                                                 readonly type: "number";
                                                                                             }];
                                                                                         };
+                                                                                        readonly modifier: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["not"];
+                                                                                        };
                                                                                     };
                                                                                 };
                                                                             };
@@ -12523,7 +13183,7 @@ export declare const redoclyConfigSchema: {
                                     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 enum: readonly ["and", "or"];
                                         };
                                         readonly conditions: {
                                             readonly type: "array";
@@ -12536,7 +13196,7 @@ export declare const redoclyConfigSchema: {
                                                         };
                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                         };
                                                         readonly value: {
                                                             readonly oneOf: readonly [{
@@ -12547,6 +13207,10 @@ export declare const redoclyConfigSchema: {
                                                                 readonly type: "number";
                                                             }];
                                                         };
+                                                        readonly modifier: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["not"];
+                                                        };
                                                         readonly match: {
                                                             readonly type: "array";
                                                             readonly items: {
@@ -12557,7 +13221,7 @@ export declare const redoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -12568,6 +13232,10 @@ export declare const redoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                 };
                                                             };
                                                         };
@@ -12577,7 +13245,7 @@ export declare const redoclyConfigSchema: {
                                                     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 enum: readonly ["and", "or"];
                                                         };
                                                         readonly conditions: {
                                                             readonly type: "array";
@@ -12590,7 +13258,7 @@ export declare const redoclyConfigSchema: {
                                                                         };
                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                         };
                                                                         readonly value: {
                                                                             readonly oneOf: readonly [{
@@ -12601,6 +13269,10 @@ export declare const redoclyConfigSchema: {
                                                                                 readonly type: "number";
                                                                             }];
                                                                         };
+                                                                        readonly modifier: {
+                                                                            readonly type: "string";
+                                                                            readonly enum: readonly ["not"];
+                                                                        };
                                                                         readonly match: {
                                                                             readonly type: "array";
                                                                             readonly items: {
@@ -12611,7 +13283,7 @@ export declare const redoclyConfigSchema: {
                                                                                     };
                                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                     };
                                                                                     readonly value: {
                                                                                         readonly oneOf: readonly [{
@@ -12622,6 +13294,10 @@ export declare const redoclyConfigSchema: {
                                                                                             readonly type: "number";
                                                                                         }];
                                                                                     };
+                                                                                    readonly modifier: {
+                                                                                        readonly type: "string";
+                                                                                        readonly enum: readonly ["not"];
+                                                                                    };
                                                                                 };
                                                                             };
                                                                         };
@@ -12631,7 +13307,7 @@ export declare const redoclyConfigSchema: {
                                                                     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 enum: readonly ["and", "or"];
                                                                         };
                                                                         readonly conditions: {
                                                                             readonly type: "array";
@@ -12643,7 +13319,7 @@ export declare const redoclyConfigSchema: {
                                                                                     };
                                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                     };
                                                                                     readonly value: {
                                                                                         readonly oneOf: readonly [{
@@ -12654,6 +13330,10 @@ export declare const redoclyConfigSchema: {
                                                                                             readonly type: "number";
                                                                                         }];
                                                                                     };
+                                                                                    readonly modifier: {
+                                                                                        readonly type: "string";
+                                                                                        readonly enum: readonly ["not"];
+                                                                                    };
                                                                                     readonly match: {
                                                                                         readonly type: "array";
                                                                                         readonly items: {
@@ -12664,7 +13344,7 @@ export declare const redoclyConfigSchema: {
                                                                                                 };
                                                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                                 };
                                                                                                 readonly value: {
                                                                                                     readonly oneOf: readonly [{
@@ -12675,6 +13355,10 @@ export declare const redoclyConfigSchema: {
                                                                                                         readonly type: "number";
                                                                                                     }];
                                                                                                 };
+                                                                                                readonly modifier: {
+                                                                                                    readonly type: "string";
+                                                                                                    readonly enum: readonly ["not"];
+                                                                                                };
                                                                                             };
                                                                                         };
                                                                                     };
@@ -18894,7 +19578,7 @@ export declare const redoclyConfigSchema: {
                                         };
                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                         };
                                         readonly value: {
                                             readonly oneOf: readonly [{
@@ -18905,6 +19589,10 @@ export declare const redoclyConfigSchema: {
                                                 readonly type: "number";
                                             }];
                                         };
+                                        readonly modifier: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["not"];
+                                        };
                                         readonly match: {
                                             readonly type: "array";
                                             readonly items: {
@@ -18915,7 +19603,7 @@ export declare const redoclyConfigSchema: {
                                                     };
                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                     };
                                                     readonly value: {
                                                         readonly oneOf: readonly [{
@@ -18926,6 +19614,10 @@ export declare const redoclyConfigSchema: {
                                                             readonly type: "number";
                                                         }];
                                                     };
+                                                    readonly modifier: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["not"];
+                                                    };
                                                 };
                                             };
                                         };
@@ -18935,7 +19627,7 @@ export declare const redoclyConfigSchema: {
                                     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 enum: readonly ["and", "or"];
                                         };
                                         readonly conditions: {
                                             readonly type: "array";
@@ -18948,7 +19640,7 @@ export declare const redoclyConfigSchema: {
                                                         };
                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                         };
                                                         readonly value: {
                                                             readonly oneOf: readonly [{
@@ -18959,6 +19651,10 @@ export declare const redoclyConfigSchema: {
                                                                 readonly type: "number";
                                                             }];
                                                         };
+                                                        readonly modifier: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["not"];
+                                                        };
                                                         readonly match: {
                                                             readonly type: "array";
                                                             readonly items: {
@@ -18969,7 +19665,7 @@ export declare const redoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -18980,6 +19676,10 @@ export declare const redoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                 };
                                                             };
                                                         };
@@ -18989,7 +19689,7 @@ export declare const redoclyConfigSchema: {
                                                     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 enum: readonly ["and", "or"];
                                                         };
                                                         readonly conditions: {
                                                             readonly type: "array";
@@ -19001,7 +19701,7 @@ export declare const redoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -19012,6 +19712,10 @@ export declare const redoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                     readonly match: {
                                                                         readonly type: "array";
                                                                         readonly items: {
@@ -19022,7 +19726,7 @@ export declare const redoclyConfigSchema: {
                                                                                 };
                                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                 };
                                                                                 readonly value: {
                                                                                     readonly oneOf: readonly [{
@@ -19033,6 +19737,10 @@ export declare const redoclyConfigSchema: {
                                                                                         readonly type: "number";
                                                                                     }];
                                                                                 };
+                                                                                readonly modifier: {
+                                                                                    readonly type: "string";
+                                                                                    readonly enum: readonly ["not"];
+                                                                                };
                                                                             };
                                                                         };
                                                                     };
@@ -19055,7 +19763,7 @@ export declare const redoclyConfigSchema: {
                             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 enum: readonly ["and", "or"];
                                 };
                                 readonly conditions: {
                                     readonly type: "array";
@@ -19068,7 +19776,7 @@ export declare const redoclyConfigSchema: {
                                                 };
                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                 };
                                                 readonly value: {
                                                     readonly oneOf: readonly [{
@@ -19079,6 +19787,10 @@ export declare const redoclyConfigSchema: {
                                                         readonly type: "number";
                                                     }];
                                                 };
+                                                readonly modifier: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["not"];
+                                                };
                                                 readonly match: {
                                                     readonly type: "array";
                                                     readonly items: {
@@ -19089,7 +19801,7 @@ export declare const redoclyConfigSchema: {
                                                             };
                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                             };
                                                             readonly value: {
                                                                 readonly oneOf: readonly [{
@@ -19100,6 +19812,10 @@ export declare const redoclyConfigSchema: {
                                                                     readonly type: "number";
                                                                 }];
                                                             };
+                                                            readonly modifier: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["not"];
+                                                            };
                                                         };
                                                     };
                                                 };
@@ -19109,7 +19825,7 @@ export declare const redoclyConfigSchema: {
                                             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 enum: readonly ["and", "or"];
                                                 };
                                                 readonly conditions: {
                                                     readonly type: "array";
@@ -19122,7 +19838,7 @@ export declare const redoclyConfigSchema: {
                                                                 };
                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                 };
                                                                 readonly value: {
                                                                     readonly oneOf: readonly [{
@@ -19133,6 +19849,10 @@ export declare const redoclyConfigSchema: {
                                                                         readonly type: "number";
                                                                     }];
                                                                 };
+                                                                readonly modifier: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["not"];
+                                                                };
                                                                 readonly match: {
                                                                     readonly type: "array";
                                                                     readonly items: {
@@ -19143,7 +19863,7 @@ export declare const redoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -19154,6 +19874,10 @@ export declare const redoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                         };
                                                                     };
                                                                 };
@@ -19163,7 +19887,7 @@ export declare const redoclyConfigSchema: {
                                                             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 enum: readonly ["and", "or"];
                                                                 };
                                                                 readonly conditions: {
                                                                     readonly type: "array";
@@ -19175,7 +19899,7 @@ export declare const redoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -19186,6 +19910,10 @@ export declare const redoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                             readonly match: {
                                                                                 readonly type: "array";
                                                                                 readonly items: {
@@ -19196,7 +19924,7 @@ export declare const redoclyConfigSchema: {
                                                                                         };
                                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                         };
                                                                                         readonly value: {
                                                                                             readonly oneOf: readonly [{
@@ -19207,6 +19935,10 @@ export declare const redoclyConfigSchema: {
                                                                                                 readonly type: "number";
                                                                                             }];
                                                                                         };
+                                                                                        readonly modifier: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["not"];
+                                                                                        };
                                                                                     };
                                                                                 };
                                                                             };
@@ -19738,6 +20470,12 @@ export declare const redoclyConfigSchema: {
                         readonly enum: readonly ["info", "success", "warning", "error"];
                         readonly default: "info";
                     };
+                    readonly rbac: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
                 };
                 readonly required: readonly ["content"];
                 readonly additionalProperties: false;
@@ -20157,6 +20895,162 @@ export declare const redoclyConfigSchema: {
                         };
                     };
                 };
+                readonly entitiesCatalog: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly catalogs: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly all: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly services: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domains: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly teams: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly users: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescriptions: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchemas: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperations: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesTypes: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly service: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domain: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly team: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly user: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescription: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperation: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchema: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesGroups: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly entities: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly config: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly entities: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly '**': {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
             };
             readonly additionalProperties: {
                 readonly type: "object";
@@ -29093,6 +29987,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             value: /*elided*/ any;
                                                             field: /*elided*/ any;
                                                             operator: /*elided*/ any;
+                                                            modifier: /*elided*/ any;
                                                             match: /*elided*/ any;
                                                         };
                                                         type: "object";
@@ -29110,7 +30005,7 @@ export declare const rootRedoclyConfigSchema: {
                                             } | {
                                                 properties: {
                                                     operator: {
-                                                        enum: ("none" | "contains" | "not" | "every" | "some" | "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "startsWith" | "endsWith" | "exists" | "isEmpty" | "between" | "matches" | "and" | "or")[];
+                                                        enum: ("and" | "or")[];
                                                         type: "string";
                                                     };
                                                     conditions: {
@@ -31954,6 +32849,158 @@ export declare const rootRedoclyConfigSchema: {
                                         };
                                         type: "object";
                                     };
+                                    entitiesCatalog: {
+                                        properties: {
+                                            entities: {
+                                                properties: {
+                                                    "**": {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                };
+                                                additionalProperties: {
+                                                    additionalProperties: {
+                                                        type: "string";
+                                                    };
+                                                    type: "object";
+                                                };
+                                                type: "object";
+                                            };
+                                            catalogs: {
+                                                properties: {
+                                                    all: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    services: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    domains: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    teams: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    users: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    apiDescriptions: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    dataSchemas: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    apiOperations: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                };
+                                                additionalProperties: {
+                                                    additionalProperties: {
+                                                        type: "string";
+                                                    };
+                                                    type: "object";
+                                                };
+                                                type: "object";
+                                            };
+                                            entitiesTypes: {
+                                                properties: {
+                                                    user: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    service: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    domain: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    team: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    apiDescription: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    apiOperation: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                    dataSchema: {
+                                                        additionalProperties: {
+                                                            type: "string";
+                                                        };
+                                                        type: "object";
+                                                    };
+                                                };
+                                                additionalProperties: {
+                                                    additionalProperties: {
+                                                        type: "string";
+                                                    };
+                                                    type: "object";
+                                                };
+                                                type: "object";
+                                            };
+                                            entitiesGroups: {
+                                                items: {
+                                                    properties: {
+                                                        entities: {
+                                                            items: /*elided*/ any;
+                                                            type: "array";
+                                                        };
+                                                        config: {
+                                                            additionalProperties: /*elided*/ any;
+                                                            type: "object";
+                                                        };
+                                                    };
+                                                    additionalProperties: false;
+                                                    type: "object";
+                                                };
+                                                type: "array";
+                                            };
+                                        };
+                                        additionalProperties: false;
+                                        type: "object";
+                                    };
                                     teamNamePatterns: {
                                         items: {
                                             type: "string";
@@ -35119,7 +36166,11 @@ export declare const rootRedoclyConfigSchema: {
                                                         type: "string";
                                                     };
                                                     operator: {
-                                                        enum: ("none" | "contains" | "not" | "every" | "some" | "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "startsWith" | "endsWith" | "exists" | "isEmpty" | "between" | "matches" | "and" | "or")[];
+                                                        enum: ("none" | "contains" | "every" | "some" | "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "startsWith" | "endsWith" | "exists" | "isEmpty" | "between" | "matches")[];
+                                                        type: "string";
+                                                    };
+                                                    modifier: {
+                                                        enum: "not"[];
                                                         type: "string";
                                                     };
                                                     match: {
@@ -35134,7 +36185,7 @@ export declare const rootRedoclyConfigSchema: {
                                             } | {
                                                 properties: {
                                                     operator: {
-                                                        enum: ("none" | "contains" | "not" | "every" | "some" | "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "startsWith" | "endsWith" | "exists" | "isEmpty" | "between" | "matches" | "and" | "or")[];
+                                                        enum: ("and" | "or")[];
                                                         type: "string";
                                                     };
                                                     conditions: {
@@ -35153,7 +36204,7 @@ export declare const rootRedoclyConfigSchema: {
                                     } | {
                                         properties: {
                                             operator: {
-                                                enum: ("none" | "contains" | "not" | "every" | "some" | "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "startsWith" | "endsWith" | "exists" | "isEmpty" | "between" | "matches" | "and" | "or")[];
+                                                enum: ("and" | "or")[];
                                                 type: "string";
                                             };
                                             conditions: {
@@ -35163,6 +36214,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             value: /*elided*/ any;
                                                             field: /*elided*/ any;
                                                             operator: /*elided*/ any;
+                                                            modifier: /*elided*/ any;
                                                             match: /*elided*/ any;
                                                         };
                                                         type: "object";
@@ -35568,6 +36620,12 @@ export declare const rootRedoclyConfigSchema: {
                                 content: {
                                     type: "string";
                                 };
+                                rbac: {
+                                    additionalProperties: {
+                                        type: "string";
+                                    };
+                                    type: "object";
+                                };
                                 dismissible: {
                                     type: "boolean";
                                 };
@@ -35741,6 +36799,162 @@ export declare const rootRedoclyConfigSchema: {
                                 };
                                 type: "object";
                             };
+                            entitiesCatalog: {
+                                properties: {
+                                    entities: {
+                                        properties: {
+                                            "**": {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                        };
+                                        additionalProperties: {
+                                            additionalProperties: {
+                                                type: "string";
+                                            };
+                                            type: "object";
+                                        };
+                                        type: "object";
+                                    };
+                                    catalogs: {
+                                        properties: {
+                                            all: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            services: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            domains: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            teams: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            users: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            apiDescriptions: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            dataSchemas: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            apiOperations: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                        };
+                                        additionalProperties: {
+                                            additionalProperties: {
+                                                type: "string";
+                                            };
+                                            type: "object";
+                                        };
+                                        type: "object";
+                                    };
+                                    entitiesTypes: {
+                                        properties: {
+                                            user: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            service: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            domain: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            team: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            apiDescription: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            apiOperation: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                            dataSchema: {
+                                                additionalProperties: {
+                                                    type: "string";
+                                                };
+                                                type: "object";
+                                            };
+                                        };
+                                        additionalProperties: {
+                                            additionalProperties: {
+                                                type: "string";
+                                            };
+                                            type: "object";
+                                        };
+                                        type: "object";
+                                    };
+                                    entitiesGroups: {
+                                        items: {
+                                            properties: {
+                                                entities: {
+                                                    items: {
+                                                        type: "string";
+                                                    };
+                                                    type: "array";
+                                                };
+                                                config: {
+                                                    additionalProperties: {
+                                                        type: "string";
+                                                    };
+                                                    type: "object";
+                                                };
+                                            };
+                                            additionalProperties: false;
+                                            type: "object";
+                                        };
+                                        type: "array";
+                                    };
+                                };
+                                additionalProperties: false;
+                                type: "object";
+                            };
                             teamNamePatterns: {
                                 items: {
                                     type: "string";
@@ -38177,6 +39391,162 @@ export declare const rootRedoclyConfigSchema: {
                                 };
                             };
                         };
+                        readonly entitiesCatalog: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly catalogs: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly all: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly services: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly domains: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly teams: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly users: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiDescriptions: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly dataSchemas: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiOperations: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly entitiesTypes: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly service: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly domain: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly team: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly user: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiDescription: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly apiOperation: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                        readonly dataSchema: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly entitiesGroups: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly properties: {
+                                            readonly entities: {
+                                                readonly type: "array";
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                            readonly config: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    };
+                                };
+                                readonly entities: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly '**': {
+                                            readonly type: "object";
+                                            readonly additionalProperties: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly additionalProperties: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
                     };
                     readonly additionalProperties: {
                         readonly type: "object";
@@ -44093,7 +45463,7 @@ export declare const rootRedoclyConfigSchema: {
                                                 };
                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                 };
                                                 readonly value: {
                                                     readonly oneOf: readonly [{
@@ -44104,6 +45474,10 @@ export declare const rootRedoclyConfigSchema: {
                                                         readonly type: "number";
                                                     }];
                                                 };
+                                                readonly modifier: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["not"];
+                                                };
                                                 readonly match: {
                                                     readonly type: "array";
                                                     readonly items: {
@@ -44114,7 +45488,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             };
                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                             };
                                                             readonly value: {
                                                                 readonly oneOf: readonly [{
@@ -44125,6 +45499,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                     readonly type: "number";
                                                                 }];
                                                             };
+                                                            readonly modifier: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["not"];
+                                                            };
                                                         };
                                                     };
                                                 };
@@ -44134,7 +45512,7 @@ export declare const rootRedoclyConfigSchema: {
                                             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 enum: readonly ["and", "or"];
                                                 };
                                                 readonly conditions: {
                                                     readonly type: "array";
@@ -44147,7 +45525,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                 };
                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                 };
                                                                 readonly value: {
                                                                     readonly oneOf: readonly [{
@@ -44158,6 +45536,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                         readonly type: "number";
                                                                     }];
                                                                 };
+                                                                readonly modifier: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["not"];
+                                                                };
                                                                 readonly match: {
                                                                     readonly type: "array";
                                                                     readonly items: {
@@ -44168,7 +45550,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -44179,6 +45561,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                         };
                                                                     };
                                                                 };
@@ -44188,7 +45574,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             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 enum: readonly ["and", "or"];
                                                                 };
                                                                 readonly conditions: {
                                                                     readonly type: "array";
@@ -44200,7 +45586,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -44211,6 +45597,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                             readonly match: {
                                                                                 readonly type: "array";
                                                                                 readonly items: {
@@ -44221,7 +45611,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                         };
                                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                         };
                                                                                         readonly value: {
                                                                                             readonly oneOf: readonly [{
@@ -44232,6 +45622,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                                 readonly type: "number";
                                                                                             }];
                                                                                         };
+                                                                                        readonly modifier: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["not"];
+                                                                                        };
                                                                                     };
                                                                                 };
                                                                             };
@@ -44254,7 +45648,7 @@ export declare const rootRedoclyConfigSchema: {
                                     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 enum: readonly ["and", "or"];
                                         };
                                         readonly conditions: {
                                             readonly type: "array";
@@ -44267,7 +45661,7 @@ export declare const rootRedoclyConfigSchema: {
                                                         };
                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                         };
                                                         readonly value: {
                                                             readonly oneOf: readonly [{
@@ -44278,6 +45672,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                 readonly type: "number";
                                                             }];
                                                         };
+                                                        readonly modifier: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["not"];
+                                                        };
                                                         readonly match: {
                                                             readonly type: "array";
                                                             readonly items: {
@@ -44288,7 +45686,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -44299,6 +45697,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                 };
                                                             };
                                                         };
@@ -44308,7 +45710,7 @@ export declare const rootRedoclyConfigSchema: {
                                                     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 enum: readonly ["and", "or"];
                                                         };
                                                         readonly conditions: {
                                                             readonly type: "array";
@@ -44321,7 +45723,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                         };
                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                         };
                                                                         readonly value: {
                                                                             readonly oneOf: readonly [{
@@ -44332,6 +45734,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                 readonly type: "number";
                                                                             }];
                                                                         };
+                                                                        readonly modifier: {
+                                                                            readonly type: "string";
+                                                                            readonly enum: readonly ["not"];
+                                                                        };
                                                                         readonly match: {
                                                                             readonly type: "array";
                                                                             readonly items: {
@@ -44342,7 +45748,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     };
                                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                     };
                                                                                     readonly value: {
                                                                                         readonly oneOf: readonly [{
@@ -44353,6 +45759,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                             readonly type: "number";
                                                                                         }];
                                                                                     };
+                                                                                    readonly modifier: {
+                                                                                        readonly type: "string";
+                                                                                        readonly enum: readonly ["not"];
+                                                                                    };
                                                                                 };
                                                                             };
                                                                         };
@@ -44362,7 +45772,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                     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 enum: readonly ["and", "or"];
                                                                         };
                                                                         readonly conditions: {
                                                                             readonly type: "array";
@@ -44374,7 +45784,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     };
                                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                     };
                                                                                     readonly value: {
                                                                                         readonly oneOf: readonly [{
@@ -44385,6 +45795,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                             readonly type: "number";
                                                                                         }];
                                                                                     };
+                                                                                    readonly modifier: {
+                                                                                        readonly type: "string";
+                                                                                        readonly enum: readonly ["not"];
+                                                                                    };
                                                                                     readonly match: {
                                                                                         readonly type: "array";
                                                                                         readonly items: {
@@ -44395,7 +45809,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                                 };
                                                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                                 };
                                                                                                 readonly value: {
                                                                                                     readonly oneOf: readonly [{
@@ -44406,6 +45820,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                                         readonly type: "number";
                                                                                                     }];
                                                                                                 };
+                                                                                                readonly modifier: {
+                                                                                                    readonly type: "string";
+                                                                                                    readonly enum: readonly ["not"];
+                                                                                                };
                                                                                             };
                                                                                         };
                                                                                     };
@@ -50625,7 +52043,7 @@ export declare const rootRedoclyConfigSchema: {
                                         };
                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                         };
                                         readonly value: {
                                             readonly oneOf: readonly [{
@@ -50636,6 +52054,10 @@ export declare const rootRedoclyConfigSchema: {
                                                 readonly type: "number";
                                             }];
                                         };
+                                        readonly modifier: {
+                                            readonly type: "string";
+                                            readonly enum: readonly ["not"];
+                                        };
                                         readonly match: {
                                             readonly type: "array";
                                             readonly items: {
@@ -50646,7 +52068,7 @@ export declare const rootRedoclyConfigSchema: {
                                                     };
                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                     };
                                                     readonly value: {
                                                         readonly oneOf: readonly [{
@@ -50657,6 +52079,10 @@ export declare const rootRedoclyConfigSchema: {
                                                             readonly type: "number";
                                                         }];
                                                     };
+                                                    readonly modifier: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["not"];
+                                                    };
                                                 };
                                             };
                                         };
@@ -50666,7 +52092,7 @@ export declare const rootRedoclyConfigSchema: {
                                     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 enum: readonly ["and", "or"];
                                         };
                                         readonly conditions: {
                                             readonly type: "array";
@@ -50679,7 +52105,7 @@ export declare const rootRedoclyConfigSchema: {
                                                         };
                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                         };
                                                         readonly value: {
                                                             readonly oneOf: readonly [{
@@ -50690,6 +52116,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                 readonly type: "number";
                                                             }];
                                                         };
+                                                        readonly modifier: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["not"];
+                                                        };
                                                         readonly match: {
                                                             readonly type: "array";
                                                             readonly items: {
@@ -50700,7 +52130,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -50711,6 +52141,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                 };
                                                             };
                                                         };
@@ -50720,7 +52154,7 @@ export declare const rootRedoclyConfigSchema: {
                                                     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 enum: readonly ["and", "or"];
                                                         };
                                                         readonly conditions: {
                                                             readonly type: "array";
@@ -50732,7 +52166,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                     };
                                                                     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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                     };
                                                                     readonly value: {
                                                                         readonly oneOf: readonly [{
@@ -50743,6 +52177,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                             readonly type: "number";
                                                                         }];
                                                                     };
+                                                                    readonly modifier: {
+                                                                        readonly type: "string";
+                                                                        readonly enum: readonly ["not"];
+                                                                    };
                                                                     readonly match: {
                                                                         readonly type: "array";
                                                                         readonly items: {
@@ -50753,7 +52191,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                 };
                                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                 };
                                                                                 readonly value: {
                                                                                     readonly oneOf: readonly [{
@@ -50764,6 +52202,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                         readonly type: "number";
                                                                                     }];
                                                                                 };
+                                                                                readonly modifier: {
+                                                                                    readonly type: "string";
+                                                                                    readonly enum: readonly ["not"];
+                                                                                };
                                                                             };
                                                                         };
                                                                     };
@@ -50786,7 +52228,7 @@ export declare const rootRedoclyConfigSchema: {
                             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 enum: readonly ["and", "or"];
                                 };
                                 readonly conditions: {
                                     readonly type: "array";
@@ -50799,7 +52241,7 @@ export declare const rootRedoclyConfigSchema: {
                                                 };
                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                 };
                                                 readonly value: {
                                                     readonly oneOf: readonly [{
@@ -50810,6 +52252,10 @@ export declare const rootRedoclyConfigSchema: {
                                                         readonly type: "number";
                                                     }];
                                                 };
+                                                readonly modifier: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["not"];
+                                                };
                                                 readonly match: {
                                                     readonly type: "array";
                                                     readonly items: {
@@ -50820,7 +52266,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             };
                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                             };
                                                             readonly value: {
                                                                 readonly oneOf: readonly [{
@@ -50831,6 +52277,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                     readonly type: "number";
                                                                 }];
                                                             };
+                                                            readonly modifier: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["not"];
+                                                            };
                                                         };
                                                     };
                                                 };
@@ -50840,7 +52290,7 @@ export declare const rootRedoclyConfigSchema: {
                                             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 enum: readonly ["and", "or"];
                                                 };
                                                 readonly conditions: {
                                                     readonly type: "array";
@@ -50853,7 +52303,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                 };
                                                                 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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                 };
                                                                 readonly value: {
                                                                     readonly oneOf: readonly [{
@@ -50864,6 +52314,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                         readonly type: "number";
                                                                     }];
                                                                 };
+                                                                readonly modifier: {
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["not"];
+                                                                };
                                                                 readonly match: {
                                                                     readonly type: "array";
                                                                     readonly items: {
@@ -50874,7 +52328,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -50885,6 +52339,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                         };
                                                                     };
                                                                 };
@@ -50894,7 +52352,7 @@ export declare const rootRedoclyConfigSchema: {
                                                             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 enum: readonly ["and", "or"];
                                                                 };
                                                                 readonly conditions: {
                                                                     readonly type: "array";
@@ -50906,7 +52364,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                             };
                                                                             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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                             };
                                                                             readonly value: {
                                                                                 readonly oneOf: readonly [{
@@ -50917,6 +52375,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                     readonly type: "number";
                                                                                 }];
                                                                             };
+                                                                            readonly modifier: {
+                                                                                readonly type: "string";
+                                                                                readonly enum: readonly ["not"];
+                                                                            };
                                                                             readonly match: {
                                                                                 readonly type: "array";
                                                                                 readonly items: {
@@ -50927,7 +52389,7 @@ export declare const rootRedoclyConfigSchema: {
                                                                                         };
                                                                                         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 enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
                                                                                         };
                                                                                         readonly value: {
                                                                                             readonly oneOf: readonly [{
@@ -50938,6 +52400,10 @@ export declare const rootRedoclyConfigSchema: {
                                                                                                 readonly type: "number";
                                                                                             }];
                                                                                         };
+                                                                                        readonly modifier: {
+                                                                                            readonly type: "string";
+                                                                                            readonly enum: readonly ["not"];
+                                                                                        };
                                                                                     };
                                                                                 };
                                                                             };
@@ -51469,6 +52935,12 @@ export declare const rootRedoclyConfigSchema: {
                         readonly enum: readonly ["info", "success", "warning", "error"];
                         readonly default: "info";
                     };
+                    readonly rbac: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "string";
+                        };
+                    };
                 };
                 readonly required: readonly ["content"];
                 readonly additionalProperties: false;
@@ -51888,6 +53360,162 @@ export declare const rootRedoclyConfigSchema: {
                         };
                     };
                 };
+                readonly entitiesCatalog: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly catalogs: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly all: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly services: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domains: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly teams: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly users: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescriptions: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchemas: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperations: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesTypes: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly service: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly domain: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly team: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly user: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiDescription: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly apiOperation: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly dataSchema: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly entitiesGroups: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly entities: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly config: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly entities: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly '**': {
+                                    readonly type: "object";
+                                    readonly additionalProperties: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly additionalProperties: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
             };
             readonly additionalProperties: {
                 readonly type: "object";