@redocly/config 0.5.0 → 0.82.2-rc.3

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

@@ -1417,6 +1417,16 @@ export declare const redoclyConfigSchema: {
                 readonly required: readonly ["root"];
             };
         };
+        readonly rules: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                }];
+            };
+        };
         readonly ssoOnPrem: {
             readonly type: "object";
             readonly additionalProperties: {
@@ -2615,7 +2625,7 @@ export declare const redoclyConfigSchema: {
                                 };
                                 readonly text: {
                                     readonly type: "string";
-                                    readonly default: "Next to {{label}}";
+                                    readonly default: "Next page";
                                 };
                             };
                             readonly additionalProperties: false;
@@ -2629,7 +2639,7 @@ export declare const redoclyConfigSchema: {
                                 };
                                 readonly text: {
                                     readonly type: "string";
-                                    readonly default: "Back to {{label}}";
+                                    readonly default: "Previous page";
                                 };
                             };
                             readonly additionalProperties: false;
@@ -3024,21 +3034,13 @@ export declare const redoclyConfigSchema: {
                         };
                     };
                 };
-                readonly userProfile: {
+                readonly userMenu: {
                     readonly type: "object";
                     readonly properties: {
                         readonly hide: {
                             readonly type: "boolean";
                         };
-                        readonly loginLabel: {
-                            readonly type: "string";
-                            readonly default: "Login";
-                        };
-                        readonly logoutLabel: {
-                            readonly type: "string";
-                            readonly default: "Logout";
-                        };
-                        readonly menu: {
+                        readonly items: {
                             readonly type: "array";
                             readonly items: {
                                 readonly type: "object";
@@ -3125,6 +3127,7 @@ export declare const redoclyConfigSchema: {
                                             readonly type: {
                                                 readonly type: "string";
                                                 readonly enum: readonly ["select", "checkboxes", "date-range"];
+                                                readonly default: "checkboxes";
                                             };
                                             readonly title: {
                                                 readonly type: "string";
@@ -3471,2275 +3474,2044 @@ export declare const rootRedoclyConfigSchema: {
                 readonly additionalProperties: false;
                 readonly type: "object";
                 readonly properties: {
-                    readonly licenseKey: {
-                        readonly type: "string";
+                    metadata: {
+                        type: "object";
+                        additionalProperties: true;
                     };
-                    readonly redirects: {
-                        readonly type: "object";
-                        readonly additionalProperties: {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly to: {
-                                    readonly type: "string";
+                    licenseKey: {
+                        type: "string";
+                    };
+                    redirects: {
+                        type: "object";
+                        additionalProperties: {
+                            type: "object";
+                            properties: {
+                                type: {
+                                    type: "number";
                                 };
-                                readonly type: {
-                                    readonly type: "number";
-                                    readonly default: 301;
+                                to: {
+                                    type: "string";
                                 };
                             };
-                            readonly additionalProperties: false;
+                            additionalProperties: false;
                         };
-                        readonly default: {};
                     };
-                    readonly seo: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly title: {
-                                readonly type: "string";
+                    seo: {
+                        type: "object";
+                        properties: {
+                            image: {
+                                type: "string";
                             };
-                            readonly description: {
-                                readonly type: "string";
+                            title: {
+                                type: "string";
                             };
-                            readonly siteUrl: {
-                                readonly type: "string";
+                            description: {
+                                type: "string";
                             };
-                            readonly image: {
-                                readonly type: "string";
+                            siteUrl: {
+                                type: "string";
                             };
-                            readonly keywords: {
-                                readonly oneOf: readonly [{
-                                    readonly type: "array";
-                                    readonly items: {
-                                        readonly type: "string";
+                            keywords: {
+                                oneOf: ({
+                                    type: "array";
+                                    items: {
+                                        type: "string";
                                     };
-                                }, {
-                                    readonly type: "string";
-                                }];
+                                } | {
+                                    type: "string";
+                                })[];
                             };
-                            readonly lang: {
-                                readonly type: "string";
+                            lang: {
+                                type: "string";
                             };
-                            readonly jsonLd: {
-                                readonly type: "object";
+                            jsonLd: {
+                                type: "object";
                             };
-                            readonly meta: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly name: {
-                                            readonly type: "string";
+                            meta: {
+                                type: "array";
+                                items: {
+                                    type: "object";
+                                    properties: {
+                                        name: {
+                                            type: "string";
                                         };
-                                        readonly content: {
-                                            readonly type: "string";
+                                        content: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly required: readonly ["name", "content"];
-                                    readonly additionalProperties: false;
+                                    additionalProperties: false;
+                                    required: ("name" | "content")[];
                                 };
                             };
                         };
-                        readonly additionalProperties: false;
+                        additionalProperties: false;
                     };
-                    readonly rbac: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly teamNamePatterns: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
+                    rbac: {
+                        type: "object";
+                        properties: {
+                            content: {
+                                type: "object";
+                                properties: {
+                                    "**": {
+                                        type: "object";
+                                        additionalProperties: {
+                                            type: "string";
+                                        };
+                                    };
                                 };
-                            };
-                            readonly teamFolders: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
+                                additionalProperties: {
+                                    type: "object";
+                                    additionalProperties: {
+                                        type: "string";
+                                    };
                                 };
                             };
-                            readonly teamFoldersBaseRoles: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly type: "string";
+                            reunite: {
+                                type: "object";
+                                additionalProperties: {
+                                    type: "string";
                                 };
                             };
-                            readonly cms: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly type: "string";
+                            teamNamePatterns: {
+                                type: "array";
+                                items: {
+                                    type: "string";
                                 };
                             };
-                            readonly reunite: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly type: "string";
+                            teamFolders: {
+                                type: "array";
+                                items: {
+                                    type: "string";
                                 };
                             };
-                            readonly content: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly '**': {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
-                                        };
-                                    };
+                            teamFoldersBaseRoles: {
+                                type: "object";
+                                additionalProperties: {
+                                    type: "string";
                                 };
-                                readonly additionalProperties: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: {
-                                        readonly type: "string";
-                                    };
+                            };
+                            cms: {
+                                type: "object";
+                                additionalProperties: {
+                                    type: "string";
                                 };
                             };
                         };
-                        readonly additionalProperties: {
-                            readonly type: "object";
-                            readonly additionalProperties: {
-                                readonly type: "string";
+                        additionalProperties: {
+                            type: "object";
+                            additionalProperties: {
+                                type: "string";
                             };
                         };
                     };
-                    readonly responseHeaders: {
-                        readonly type: "object";
-                        readonly additionalProperties: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly name: {
-                                        readonly type: "string";
+                    responseHeaders: {
+                        type: "object";
+                        additionalProperties: {
+                            type: "array";
+                            items: {
+                                type: "object";
+                                properties: {
+                                    name: {
+                                        type: "string";
                                     };
-                                    readonly value: {
-                                        readonly type: "string";
+                                    value: {
+                                        type: "string";
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly required: readonly ["name", "value"];
+                                additionalProperties: false;
+                                required: ("name" | "value")[];
                             };
                         };
                     };
-                    readonly mockServer: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly off: {
-                                readonly type: "boolean";
-                                readonly default: false;
+                    mockServer: {
+                        type: "object";
+                        properties: {
+                            off: {
+                                type: "boolean";
                             };
-                            readonly position: {
-                                readonly type: "string";
-                                readonly enum: readonly ["first", "last", "replace", "off"];
-                                readonly default: "first";
+                            description: {
+                                type: "string";
                             };
-                            readonly strictExamples: {
-                                readonly type: "boolean";
-                                readonly default: false;
+                            position: {
+                                type: "string";
+                                enum: ("first" | "last" | "replace" | "off")[];
                             };
-                            readonly errorIfForcedExampleNotFound: {
-                                readonly type: "boolean";
-                                readonly default: false;
+                            strictExamples: {
+                                type: "boolean";
                             };
-                            readonly description: {
-                                readonly type: "string";
+                            errorIfForcedExampleNotFound: {
+                                type: "boolean";
                             };
                         };
                     };
-                    readonly apis: {
-                        readonly type: "object";
-                        readonly additionalProperties: {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly root: {
-                                    readonly type: "string";
+                    apis: {
+                        type: "object";
+                        additionalProperties: {
+                            type: "object";
+                            properties: {
+                                title: {
+                                    type: "string";
                                 };
-                                readonly output: {
-                                    readonly type: "string";
-                                    readonly pattern: "(.ya?ml|.json)$";
+                                metadata: {
+                                    type: "object";
+                                    additionalProperties: true;
                                 };
-                                readonly rbac: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: true;
+                                root: {
+                                    type: "string";
                                 };
-                                readonly theme: {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly openapi: {
-                                            readonly type: "object";
-                                            readonly additionalProperties: true;
+                                rbac: {
+                                    type: "object";
+                                    additionalProperties: true;
+                                };
+                                rules: {
+                                    type: "object";
+                                    additionalProperties: true;
+                                };
+                                theme: {
+                                    type: "object";
+                                    properties: {
+                                        openapi: {
+                                            type: "object";
+                                            additionalProperties: true;
                                         };
-                                        readonly graphql: {
-                                            readonly type: "object";
-                                            readonly additionalProperties: true;
+                                        graphql: {
+                                            type: "object";
+                                            additionalProperties: true;
                                         };
                                     };
-                                    readonly additionalProperties: false;
-                                };
-                                readonly title: {
-                                    readonly type: "string";
-                                };
-                                readonly metadata: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: true;
+                                    additionalProperties: false;
                                 };
-                                readonly rules: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: true;
+                                output: {
+                                    type: "string";
+                                    pattern: "(.ya?ml|.json)$";
                                 };
-                                readonly decorators: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: true;
+                                decorators: {
+                                    type: "object";
+                                    additionalProperties: true;
                                 };
-                                readonly preprocessors: {
-                                    readonly type: "object";
-                                    readonly additionalProperties: true;
+                                preprocessors: {
+                                    type: "object";
+                                    additionalProperties: true;
                                 };
                             };
-                            readonly required: readonly ["root"];
+                            required: "root"[];
                         };
                     };
-                    readonly ssoOnPrem: {
-                        readonly type: "object";
-                        readonly additionalProperties: {
-                            readonly oneOf: readonly [{
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly type: {
-                                        readonly type: "string";
-                                        readonly const: AuthProviderType.OIDC;
-                                    };
-                                    readonly title: {
-                                        readonly type: "string";
+                    rules: {
+                        type: "object";
+                        additionalProperties: {
+                            oneOf: ({
+                                type: "string";
+                            } | {
+                                type: "object";
+                            })[];
+                        };
+                    };
+                    ssoOnPrem: {
+                        type: "object";
+                        additionalProperties: {
+                            oneOf: ({
+                                type: "object";
+                                properties: {
+                                    type: {
+                                        type: "string";
+                                        const: AuthProviderType.OIDC;
                                     };
-                                    readonly pkce: {
-                                        readonly type: "boolean";
-                                        readonly default: false;
+                                    clientId: {
+                                        type: "string";
+                                        minLength: 1;
                                     };
-                                    readonly configurationUrl: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                                    configurationUrl: {
+                                        type: "string";
+                                        minLength: 1;
                                     };
-                                    readonly configuration: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly end_session_endpoint: {
-                                                readonly type: "string";
+                                    configuration: {
+                                        type: "object";
+                                        properties: {
+                                            token_endpoint: {
+                                                type: "string";
                                             };
-                                            readonly token_endpoint: {
-                                                readonly type: "string";
+                                            authorization_endpoint: {
+                                                type: "string";
                                             };
-                                            readonly authorization_endpoint: {
-                                                readonly type: "string";
+                                            end_session_endpoint: {
+                                                type: "string";
                                             };
-                                            readonly jwks_uri: {
-                                                readonly type: "string";
+                                            jwks_uri: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly required: readonly ["token_endpoint", "authorization_endpoint"];
-                                        readonly additionalProperties: true;
+                                        additionalProperties: true;
+                                        required: ("token_endpoint" | "authorization_endpoint")[];
                                     };
-                                    readonly clientId: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                                    title: {
+                                        type: "string";
                                     };
-                                    readonly clientSecret: {
-                                        readonly type: "string";
-                                        readonly minLength: 0;
+                                    clientSecret: {
+                                        type: "string";
+                                        minLength: 0;
                                     };
-                                    readonly teamsClaimName: {
-                                        readonly type: "string";
+                                    pkce: {
+                                        type: "boolean";
                                     };
-                                    readonly teamsClaimMap: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
+                                    teamsClaimName: {
+                                        type: "string";
+                                    };
+                                    teamsClaimMap: {
+                                        type: "object";
+                                        additionalProperties: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly defaultTeams: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    defaultTeams: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly scopes: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    scopes: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly tokenExpirationTime: {
-                                        readonly type: "number";
+                                    tokenExpirationTime: {
+                                        type: "number";
                                     };
-                                    readonly authorizationRequestCustomParams: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
+                                    authorizationRequestCustomParams: {
+                                        type: "object";
+                                        additionalProperties: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly tokenRequestCustomParams: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
+                                    tokenRequestCustomParams: {
+                                        type: "object";
+                                        additionalProperties: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly audience: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    audience: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
                                     };
                                 };
-                                readonly required: readonly ["type", "clientId"];
-                                readonly oneOf: readonly [{
-                                    readonly required: readonly ["configurationUrl"];
-                                }, {
-                                    readonly required: readonly ["configuration"];
-                                }];
-                                readonly additionalProperties: false;
-                            }, {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly type: {
-                                        readonly type: "string";
-                                        readonly const: AuthProviderType.SAML2;
+                                additionalProperties: false;
+                                oneOf: ({
+                                    required: "configurationUrl"[];
+                                } | {
+                                    required: "configuration"[];
+                                })[];
+                                required: ("type" | "clientId")[];
+                            } | {
+                                type: "object";
+                                properties: {
+                                    type: {
+                                        type: "string";
+                                        const: AuthProviderType.SAML2;
                                     };
-                                    readonly title: {
-                                        readonly type: "string";
+                                    issuerId: {
+                                        type: "string";
                                     };
-                                    readonly issuerId: {
-                                        readonly type: "string";
+                                    ssoUrl: {
+                                        type: "string";
                                     };
-                                    readonly entityId: {
-                                        readonly type: "string";
+                                    x509PublicCert: {
+                                        type: "string";
                                     };
-                                    readonly ssoUrl: {
-                                        readonly type: "string";
+                                    title: {
+                                        type: "string";
                                     };
-                                    readonly x509PublicCert: {
-                                        readonly type: "string";
+                                    defaultTeams: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
+                                        };
                                     };
-                                    readonly teamsAttributeName: {
-                                        readonly type: "string";
-                                        readonly default: "https://redocly.com/sso/teams";
+                                    entityId: {
+                                        type: "string";
                                     };
-                                    readonly teamsAttributeMap: {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "string";
-                                        };
+                                    teamsAttributeName: {
+                                        type: "string";
                                     };
-                                    readonly defaultTeams: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    teamsAttributeMap: {
+                                        type: "object";
+                                        additionalProperties: {
+                                            type: "string";
                                         };
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly required: readonly ["type", "issuerId", "ssoUrl", "x509PublicCert"];
-                            }, {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly type: {
-                                        readonly type: "string";
-                                        readonly const: AuthProviderType.BASIC;
-                                    };
-                                    readonly title: {
-                                        readonly type: "string";
+                                additionalProperties: false;
+                                required: ("type" | "issuerId" | "ssoUrl" | "x509PublicCert")[];
+                            } | {
+                                type: "object";
+                                properties: {
+                                    type: {
+                                        type: "string";
+                                        const: AuthProviderType.BASIC;
                                     };
-                                    readonly credentials: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly username: {
-                                                    readonly type: "string";
+                                    credentials: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                username: {
+                                                    type: "string";
                                                 };
-                                                readonly password: {
-                                                    readonly type: "string";
+                                                password: {
+                                                    type: "string";
                                                 };
-                                                readonly passwordHash: {
-                                                    readonly type: "string";
+                                                passwordHash: {
+                                                    type: "string";
                                                 };
-                                                readonly teams: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "string";
+                                                teams: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "string";
                                                     };
                                                 };
                                             };
-                                            readonly required: readonly ["username"];
-                                            readonly additionalProperties: false;
+                                            additionalProperties: false;
+                                            required: "username"[];
                                         };
                                     };
+                                    title: {
+                                        type: "string";
+                                    };
                                 };
-                                readonly required: readonly ["type", "credentials"];
-                                readonly additionalProperties: false;
-                            }];
-                            readonly discriminator: {
-                                readonly propertyName: "type";
+                                additionalProperties: false;
+                                required: ("type" | "credentials")[];
+                            })[];
+                            discriminator: {
+                                propertyName: "type";
                             };
                         };
                     };
-                    readonly sso: {
-                        readonly oneOf: readonly [{
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "string";
-                                readonly enum: readonly ["REDOCLY", "CORPORATE", "GUEST"];
+                    sso: {
+                        oneOf: ({
+                            type: "array";
+                            items: {
+                                type: "string";
+                                enum: ("REDOCLY" | "CORPORATE" | "GUEST")[];
                             };
-                            readonly uniqueItems: true;
-                        }, {
-                            readonly type: "string";
-                            readonly enum: readonly ["REDOCLY", "CORPORATE", "GUEST"];
-                        }];
+                            uniqueItems: true;
+                        } | {
+                            type: "string";
+                            enum: ("REDOCLY" | "CORPORATE" | "GUEST")[];
+                        })[];
                     };
-                    readonly residency: {
-                        readonly type: "string";
+                    residency: {
+                        type: "string";
                     };
-                    readonly developerOnboarding: {
-                        readonly type: "object";
-                        readonly required: readonly ["adapters"];
-                        readonly additionalProperties: false;
-                        readonly properties: {
-                            readonly adapters: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "object";
-                                    readonly oneOf: readonly [{
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly type: {
-                                                readonly type: "string";
-                                                readonly const: "APIGEE_X";
+                    developerOnboarding: {
+                        type: "object";
+                        properties: {
+                            adapters: {
+                                type: "array";
+                                items: {
+                                    type: "object";
+                                    oneOf: ({
+                                        type: "object";
+                                        properties: {
+                                            type: {
+                                                type: "string";
+                                                const: "GRAVITEE";
                                             };
-                                            readonly apiUrl: {
-                                                readonly type: "string";
+                                            apiBaseUrl: {
+                                                type: "string";
                                             };
-                                            readonly stage: {
-                                                readonly type: "string";
-                                                readonly default: "non-production";
+                                            auth: {
+                                                type: "object";
+                                                properties: {
+                                                    static: {
+                                                        type: "string";
+                                                    };
+                                                };
                                             };
-                                            readonly organizationName: {
-                                                readonly type: "string";
+                                            env: {
+                                                type: "string";
                                             };
-                                            readonly ignoreApiProducts: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "string";
-                                                };
+                                            allowApiProductsOutsideCatalog: {
+                                                type: "boolean";
                                             };
-                                            readonly allowApiProductsOutsideCatalog: {
-                                                readonly type: "boolean";
-                                                readonly default: false;
+                                            stage: {
+                                                type: "string";
                                             };
-                                            readonly auth: {
-                                                readonly type: "object";
-                                                readonly oneOf: readonly [{
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly const: ApigeeDevOnboardingIntegrationAuthType.OAUTH2;
+                                        };
+                                        additionalProperties: false;
+                                        required: ("type" | "apiBaseUrl")[];
+                                    } | {
+                                        type: "object";
+                                        properties: {
+                                            type: {
+                                                type: "string";
+                                                const: "APIGEE_X";
+                                            };
+                                            organizationName: {
+                                                type: "string";
+                                            };
+                                            auth: {
+                                                type: "object";
+                                                oneOf: ({
+                                                    type: "object";
+                                                    properties: {
+                                                        type: {
+                                                            type: "string";
+                                                            const: ApigeeDevOnboardingIntegrationAuthType.OAUTH2;
                                                         };
-                                                        readonly tokenEndpoint: {
-                                                            readonly type: "string";
+                                                        clientId: {
+                                                            type: "string";
                                                         };
-                                                        readonly clientId: {
-                                                            readonly type: "string";
+                                                        tokenEndpoint: {
+                                                            type: "string";
                                                         };
-                                                        readonly clientSecret: {
-                                                            readonly type: "string";
+                                                        clientSecret: {
+                                                            type: "string";
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["type", "tokenEndpoint", "clientId", "clientSecret"];
-                                                }, {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly const: ApigeeDevOnboardingIntegrationAuthType.SERVICE_ACCOUNT;
+                                                    additionalProperties: false;
+                                                    required: ("type" | "clientId" | "tokenEndpoint" | "clientSecret")[];
+                                                } | {
+                                                    type: "object";
+                                                    properties: {
+                                                        type: {
+                                                            type: "string";
+                                                            const: ApigeeDevOnboardingIntegrationAuthType.SERVICE_ACCOUNT;
                                                         };
-                                                        readonly serviceAccountEmail: {
-                                                            readonly type: "string";
+                                                        serviceAccountEmail: {
+                                                            type: "string";
                                                         };
-                                                        readonly serviceAccountPrivateKey: {
-                                                            readonly type: "string";
+                                                        serviceAccountPrivateKey: {
+                                                            type: "string";
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["type", "serviceAccountEmail", "serviceAccountPrivateKey"];
-                                                }];
-                                                readonly discriminator: {
-                                                    readonly propertyName: "type";
+                                                    additionalProperties: false;
+                                                    required: ("type" | "serviceAccountEmail" | "serviceAccountPrivateKey")[];
+                                                })[];
+                                                discriminator: {
+                                                    propertyName: "type";
                                                 };
                                             };
-                                        };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["type", "organizationName", "auth"];
-                                    }, {
-                                        readonly properties: {
-                                            readonly type: {
-                                                readonly type: "string";
-                                                readonly const: "APIGEE_EDGE";
-                                            };
-                                            readonly apiUrl: {
-                                                readonly type: "string";
+                                            allowApiProductsOutsideCatalog: {
+                                                type: "boolean";
                                             };
-                                            readonly stage: {
-                                                readonly type: "string";
-                                                readonly default: "non-production";
+                                            stage: {
+                                                type: "string";
                                             };
-                                            readonly organizationName: {
-                                                readonly type: "string";
+                                            apiUrl: {
+                                                type: "string";
                                             };
-                                            readonly ignoreApiProducts: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "string";
+                                            ignoreApiProducts: {
+                                                type: "array";
+                                                items: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly allowApiProductsOutsideCatalog: {
-                                                readonly type: "boolean";
-                                                readonly default: false;
+                                        };
+                                        additionalProperties: false;
+                                        required: ("type" | "organizationName" | "auth")[];
+                                    } | {
+                                        type: "object";
+                                        properties: {
+                                            type: {
+                                                type: "string";
+                                                const: "APIGEE_EDGE";
                                             };
-                                            readonly auth: {
-                                                readonly type: "object";
-                                                readonly oneOf: readonly [{
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly const: ApigeeDevOnboardingIntegrationAuthType.OAUTH2;
+                                            organizationName: {
+                                                type: "string";
+                                            };
+                                            auth: {
+                                                type: "object";
+                                                oneOf: ({
+                                                    type: "object";
+                                                    properties: {
+                                                        type: {
+                                                            type: "string";
+                                                            const: ApigeeDevOnboardingIntegrationAuthType.OAUTH2;
                                                         };
-                                                        readonly tokenEndpoint: {
-                                                            readonly type: "string";
+                                                        clientId: {
+                                                            type: "string";
                                                         };
-                                                        readonly clientId: {
-                                                            readonly type: "string";
+                                                        tokenEndpoint: {
+                                                            type: "string";
                                                         };
-                                                        readonly clientSecret: {
-                                                            readonly type: "string";
+                                                        clientSecret: {
+                                                            type: "string";
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["type", "tokenEndpoint", "clientId", "clientSecret"];
-                                                }, {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly const: ApigeeDevOnboardingIntegrationAuthType.SERVICE_ACCOUNT;
+                                                    additionalProperties: false;
+                                                    required: ("type" | "clientId" | "tokenEndpoint" | "clientSecret")[];
+                                                } | {
+                                                    type: "object";
+                                                    properties: {
+                                                        type: {
+                                                            type: "string";
+                                                            const: ApigeeDevOnboardingIntegrationAuthType.SERVICE_ACCOUNT;
                                                         };
-                                                        readonly serviceAccountEmail: {
-                                                            readonly type: "string";
+                                                        serviceAccountEmail: {
+                                                            type: "string";
                                                         };
-                                                        readonly serviceAccountPrivateKey: {
-                                                            readonly type: "string";
+                                                        serviceAccountPrivateKey: {
+                                                            type: "string";
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["type", "serviceAccountEmail", "serviceAccountPrivateKey"];
-                                                }];
-                                                readonly discriminator: {
-                                                    readonly propertyName: "type";
+                                                    additionalProperties: false;
+                                                    required: ("type" | "serviceAccountEmail" | "serviceAccountPrivateKey")[];
+                                                })[];
+                                                discriminator: {
+                                                    propertyName: "type";
                                                 };
                                             };
-                                        };
-                                        readonly type: "object";
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["type", "organizationName", "auth"];
-                                    }, {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly type: {
-                                                readonly type: "string";
-                                                readonly const: "GRAVITEE";
+                                            allowApiProductsOutsideCatalog: {
+                                                type: "boolean";
                                             };
-                                            readonly apiBaseUrl: {
-                                                readonly type: "string";
+                                            stage: {
+                                                type: "string";
                                             };
-                                            readonly env: {
-                                                readonly type: "string";
-                                            };
-                                            readonly allowApiProductsOutsideCatalog: {
-                                                readonly type: "boolean";
-                                                readonly default: false;
+                                            apiUrl: {
+                                                type: "string";
                                             };
-                                            readonly stage: {
-                                                readonly type: "string";
-                                                readonly default: "non-production";
-                                            };
-                                            readonly auth: {
-                                                readonly type: "object";
-                                                readonly properties: {
-                                                    readonly static: {
-                                                        readonly type: "string";
-                                                    };
+                                            ignoreApiProducts: {
+                                                type: "array";
+                                                items: {
+                                                    type: "string";
                                                 };
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["type", "apiBaseUrl"];
-                                    }];
-                                    readonly discriminator: {
-                                        readonly propertyName: "type";
+                                        additionalProperties: false;
+                                        required: ("type" | "organizationName" | "auth")[];
+                                    })[];
+                                    discriminator: {
+                                        propertyName: "type";
                                     };
                                 };
                             };
                         };
+                        additionalProperties: false;
+                        required: "adapters"[];
                     };
-                    readonly removeAttribution: {
-                        readonly type: "boolean";
+                    removeAttribution: {
+                        type: "boolean";
                     };
-                    readonly i18n: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly defaultLocale: {
-                                readonly type: "string";
+                    i18n: {
+                        type: "object";
+                        properties: {
+                            defaultLocale: {
+                                type: "string";
                             };
-                            readonly locales: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly code: {
-                                            readonly type: "string";
+                            locales: {
+                                type: "array";
+                                items: {
+                                    type: "object";
+                                    properties: {
+                                        name: {
+                                            type: "string";
                                         };
-                                        readonly name: {
-                                            readonly type: "string";
+                                        code: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly required: readonly ["code"];
+                                    required: "code"[];
                                 };
                             };
                         };
-                        readonly additionalProperties: false;
-                        readonly required: readonly ["defaultLocale"];
-                    };
-                    readonly metadata: {
-                        readonly type: "object";
-                        readonly additionalProperties: true;
+                        additionalProperties: false;
+                        required: "defaultLocale"[];
                     };
-                    readonly ignore: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
+                    ignore: {
+                        type: "array";
+                        items: {
+                            type: "string";
                         };
                     };
-                    readonly theme: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly imports: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
-                                };
-                                readonly default: readonly [];
-                            };
-                            readonly logo: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly image: {
-                                        readonly type: "string";
-                                    };
-                                    readonly srcSet: {
-                                        readonly type: "string";
-                                    };
-                                    readonly altText: {
-                                        readonly type: "string";
-                                    };
-                                    readonly link: {
-                                        readonly type: "string";
-                                    };
-                                    readonly favicon: {
-                                        readonly type: "string";
-                                    };
-                                };
-                                readonly additionalProperties: false;
-                            };
-                            readonly navbar: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
-                                    };
-                                    readonly items: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly properties: {
-                                                readonly items: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly page: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly directory: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly disconnect: {
-                                                                readonly type: "boolean";
-                                                                readonly default: false;
-                                                            };
-                                                            readonly group: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly label: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly href: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly external: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly labelTranslationKey: {
-                                                                readonly type: "string";
+                    theme: {
+                        type: "object";
+                        properties: {
+                            navbar: {
+                                type: "object";
+                                properties: {
+                                    items: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                href: {
+                                                    type: "string";
+                                                };
+                                                page: {
+                                                    type: "string";
+                                                };
+                                                icon: {
+                                                    oneOf: ({
+                                                        type: "string";
+                                                    } | {
+                                                        type: "object";
+                                                        properties: {
+                                                            srcSet: any;
+                                                        };
+                                                        required: "srcSet"[];
+                                                    })[];
+                                                };
+                                                items: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "object";
+                                                        properties: {
+                                                            href: {
+                                                                type: "string";
                                                             };
-                                                            readonly groupTranslationKey: {
-                                                                readonly type: "string";
+                                                            page: {
+                                                                type: "string";
                                                             };
-                                                            readonly icon: {
-                                                                readonly oneOf: readonly [{
-                                                                    readonly type: "string";
-                                                                }, {
-                                                                    readonly type: "object";
-                                                                    readonly properties: {
-                                                                        readonly srcSet: {
-                                                                            readonly type: "string";
-                                                                        };
+                                                            icon: {
+                                                                oneOf: ({
+                                                                    type: "string";
+                                                                } | {
+                                                                    type: "object";
+                                                                    properties: {
+                                                                        srcSet: any;
                                                                     };
-                                                                    readonly required: readonly ["srcSet"];
-                                                                }];
-                                                            };
-                                                            readonly separator: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly separatorLine: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly linePosition: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["top", "bottom"];
-                                                                readonly default: "top";
-                                                            };
-                                                            readonly version: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly menuStyle: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["drilldown"];
-                                                            };
-                                                            readonly expanded: {
-                                                                readonly type: "string";
-                                                                readonly const: "always";
-                                                            };
-                                                            readonly selectFirstItemOnExpand: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly flatten: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly linkedSidebars: {
-                                                                readonly type: "array";
-                                                                readonly items: {
-                                                                    readonly type: "string";
-                                                                };
-                                                            };
-                                                            readonly items: {
-                                                                readonly type: "array";
-                                                                readonly items: {
-                                                                    readonly type: "object";
-                                                                    readonly additionalProperties: true;
-                                                                };
+                                                                    required: "srcSet"[];
+                                                                })[];
                                                             };
+                                                            items: any;
+                                                            directory: any;
+                                                            disconnect: any;
+                                                            group: any;
+                                                            label: any;
+                                                            external: any;
+                                                            labelTranslationKey: any;
+                                                            groupTranslationKey: any;
+                                                            separator: any;
+                                                            separatorLine: any;
+                                                            linePosition: any;
+                                                            version: any;
+                                                            menuStyle: any;
+                                                            expanded: any;
+                                                            selectFirstItemOnExpand: any;
+                                                            flatten: any;
+                                                            linkedSidebars: any;
                                                         };
                                                     };
                                                 };
-                                                readonly page: {
-                                                    readonly type: "string";
+                                                directory: {
+                                                    type: "string";
                                                 };
-                                                readonly directory: {
-                                                    readonly type: "string";
+                                                disconnect: {
+                                                    type: "boolean";
                                                 };
-                                                readonly disconnect: {
-                                                    readonly type: "boolean";
-                                                    readonly default: false;
+                                                group: {
+                                                    type: "string";
                                                 };
-                                                readonly group: {
-                                                    readonly type: "string";
+                                                label: {
+                                                    type: "string";
                                                 };
-                                                readonly label: {
-                                                    readonly type: "string";
+                                                external: {
+                                                    type: "boolean";
                                                 };
-                                                readonly href: {
-                                                    readonly type: "string";
+                                                labelTranslationKey: {
+                                                    type: "string";
                                                 };
-                                                readonly external: {
-                                                    readonly type: "boolean";
+                                                groupTranslationKey: {
+                                                    type: "string";
                                                 };
-                                                readonly labelTranslationKey: {
-                                                    readonly type: "string";
+                                                separator: {
+                                                    type: "string";
                                                 };
-                                                readonly groupTranslationKey: {
-                                                    readonly type: "string";
+                                                separatorLine: {
+                                                    type: "boolean";
                                                 };
-                                                readonly icon: {
-                                                    readonly oneOf: readonly [{
-                                                        readonly type: "string";
-                                                    }, {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly srcSet: {
-                                                                readonly type: "string";
-                                                            };
-                                                        };
-                                                        readonly required: readonly ["srcSet"];
-                                                    }];
+                                                linePosition: {
+                                                    type: "string";
+                                                    enum: ("top" | "bottom")[];
                                                 };
-                                                readonly separator: {
-                                                    readonly type: "string";
+                                                version: {
+                                                    type: "string";
                                                 };
-                                                readonly separatorLine: {
-                                                    readonly type: "boolean";
+                                                menuStyle: {
+                                                    type: "string";
+                                                    enum: "drilldown"[];
                                                 };
-                                                readonly linePosition: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["top", "bottom"];
-                                                    readonly default: "top";
+                                                expanded: {
+                                                    type: "string";
+                                                    const: "always";
                                                 };
-                                                readonly version: {
-                                                    readonly type: "string";
+                                                selectFirstItemOnExpand: {
+                                                    type: "boolean";
                                                 };
-                                                readonly menuStyle: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["drilldown"];
+                                                flatten: {
+                                                    type: "boolean";
                                                 };
-                                                readonly expanded: {
-                                                    readonly type: "string";
-                                                    readonly const: "always";
-                                                };
-                                                readonly selectFirstItemOnExpand: {
-                                                    readonly type: "boolean";
-                                                };
-                                                readonly flatten: {
-                                                    readonly type: "boolean";
-                                                };
-                                                readonly linkedSidebars: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "string";
+                                                linkedSidebars: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "string";
                                                     };
                                                 };
                                             };
-                                            readonly type: "object";
                                         };
                                     };
+                                    hide: {
+                                        type: "boolean";
+                                    };
                                 };
-                                readonly additionalProperties: false;
+                                additionalProperties: false;
                             };
-                            readonly products: {
-                                readonly type: "object";
-                                readonly additionalProperties: {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly name: {
-                                            readonly type: "string";
+                            links: {
+                                type: "array";
+                                items: {
+                                    type: "object";
+                                    properties: {
+                                        type: {
+                                            type: "string";
                                         };
-                                        readonly icon: {
-                                            readonly type: "string";
+                                        href: {
+                                            type: "string";
                                         };
-                                        readonly folder: {
-                                            readonly type: "string";
+                                        title: {
+                                            type: "string";
+                                        };
+                                        as: {
+                                            type: "string";
+                                        };
+                                        crossorigin: {
+                                            type: "string";
+                                        };
+                                        fetchpriority: {
+                                            type: "string";
+                                        };
+                                        hreflang: {
+                                            type: "string";
+                                        };
+                                        imagesizes: {
+                                            type: "string";
+                                        };
+                                        imagesrcset: {
+                                            type: "string";
+                                        };
+                                        integrity: {
+                                            type: "string";
+                                        };
+                                        media: {
+                                            type: "string";
+                                        };
+                                        prefetch: {
+                                            type: "string";
+                                        };
+                                        referrerpolicy: {
+                                            type: "string";
+                                        };
+                                        rel: {
+                                            type: "string";
+                                        };
+                                        sizes: {
+                                            type: "string";
                                         };
                                     };
-                                    readonly additionalProperties: false;
-                                    readonly required: readonly ["name", "folder"];
+                                    additionalProperties: true;
+                                    required: "href"[];
                                 };
                             };
-                            readonly footer: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            openapi: {
+                                type: "object";
+                                additionalProperties: true;
+                            };
+                            graphql: {
+                                type: "object";
+                                additionalProperties: true;
+                            };
+                            imports: {
+                                type: "array";
+                                items: {
+                                    type: "string";
+                                };
+                            };
+                            logo: {
+                                type: "object";
+                                properties: {
+                                    srcSet: {
+                                        type: "string";
                                     };
-                                    readonly items: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly properties: {
-                                                readonly items: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly page: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly directory: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly disconnect: {
-                                                                readonly type: "boolean";
-                                                                readonly default: false;
-                                                            };
-                                                            readonly group: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly label: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly href: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly external: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly labelTranslationKey: {
-                                                                readonly type: "string";
+                                    image: {
+                                        type: "string";
+                                    };
+                                    altText: {
+                                        type: "string";
+                                    };
+                                    link: {
+                                        type: "string";
+                                    };
+                                    favicon: {
+                                        type: "string";
+                                    };
+                                };
+                                additionalProperties: false;
+                            };
+                            products: {
+                                type: "object";
+                                additionalProperties: {
+                                    type: "object";
+                                    properties: {
+                                        name: {
+                                            type: "string";
+                                        };
+                                        folder: {
+                                            type: "string";
+                                        };
+                                        icon: {
+                                            type: "string";
+                                        };
+                                    };
+                                    additionalProperties: false;
+                                    required: ("name" | "folder")[];
+                                };
+                            };
+                            footer: {
+                                type: "object";
+                                properties: {
+                                    items: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                href: {
+                                                    type: "string";
+                                                };
+                                                page: {
+                                                    type: "string";
+                                                };
+                                                icon: {
+                                                    oneOf: ({
+                                                        type: "string";
+                                                    } | {
+                                                        type: "object";
+                                                        properties: {
+                                                            srcSet: any;
+                                                        };
+                                                        required: "srcSet"[];
+                                                    })[];
+                                                };
+                                                items: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "object";
+                                                        properties: {
+                                                            href: {
+                                                                type: "string";
                                                             };
-                                                            readonly groupTranslationKey: {
-                                                                readonly type: "string";
+                                                            page: {
+                                                                type: "string";
                                                             };
-                                                            readonly icon: {
-                                                                readonly oneOf: readonly [{
-                                                                    readonly type: "string";
-                                                                }, {
-                                                                    readonly type: "object";
-                                                                    readonly properties: {
-                                                                        readonly srcSet: {
-                                                                            readonly type: "string";
-                                                                        };
+                                                            icon: {
+                                                                oneOf: ({
+                                                                    type: "string";
+                                                                } | {
+                                                                    type: "object";
+                                                                    properties: {
+                                                                        srcSet: any;
                                                                     };
-                                                                    readonly required: readonly ["srcSet"];
-                                                                }];
-                                                            };
-                                                            readonly separator: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly separatorLine: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly linePosition: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["top", "bottom"];
-                                                                readonly default: "top";
-                                                            };
-                                                            readonly version: {
-                                                                readonly type: "string";
-                                                            };
-                                                            readonly menuStyle: {
-                                                                readonly type: "string";
-                                                                readonly enum: readonly ["drilldown"];
-                                                            };
-                                                            readonly expanded: {
-                                                                readonly type: "string";
-                                                                readonly const: "always";
-                                                            };
-                                                            readonly selectFirstItemOnExpand: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly flatten: {
-                                                                readonly type: "boolean";
-                                                            };
-                                                            readonly linkedSidebars: {
-                                                                readonly type: "array";
-                                                                readonly items: {
-                                                                    readonly type: "string";
-                                                                };
-                                                            };
-                                                            readonly items: {
-                                                                readonly type: "array";
-                                                                readonly items: {
-                                                                    readonly type: "object";
-                                                                    readonly additionalProperties: true;
-                                                                };
+                                                                    required: "srcSet"[];
+                                                                })[];
                                                             };
+                                                            items: any;
+                                                            directory: any;
+                                                            disconnect: any;
+                                                            group: any;
+                                                            label: any;
+                                                            external: any;
+                                                            labelTranslationKey: any;
+                                                            groupTranslationKey: any;
+                                                            separator: any;
+                                                            separatorLine: any;
+                                                            linePosition: any;
+                                                            version: any;
+                                                            menuStyle: any;
+                                                            expanded: any;
+                                                            selectFirstItemOnExpand: any;
+                                                            flatten: any;
+                                                            linkedSidebars: any;
                                                         };
                                                     };
                                                 };
-                                                readonly page: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly directory: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly disconnect: {
-                                                    readonly type: "boolean";
-                                                    readonly default: false;
-                                                };
-                                                readonly group: {
-                                                    readonly type: "string";
+                                                directory: {
+                                                    type: "string";
                                                 };
-                                                readonly label: {
-                                                    readonly type: "string";
+                                                disconnect: {
+                                                    type: "boolean";
                                                 };
-                                                readonly href: {
-                                                    readonly type: "string";
+                                                group: {
+                                                    type: "string";
                                                 };
-                                                readonly external: {
-                                                    readonly type: "boolean";
+                                                label: {
+                                                    type: "string";
                                                 };
-                                                readonly labelTranslationKey: {
-                                                    readonly type: "string";
+                                                external: {
+                                                    type: "boolean";
                                                 };
-                                                readonly groupTranslationKey: {
-                                                    readonly type: "string";
+                                                labelTranslationKey: {
+                                                    type: "string";
                                                 };
-                                                readonly icon: {
-                                                    readonly oneOf: readonly [{
-                                                        readonly type: "string";
-                                                    }, {
-                                                        readonly type: "object";
-                                                        readonly properties: {
-                                                            readonly srcSet: {
-                                                                readonly type: "string";
-                                                            };
-                                                        };
-                                                        readonly required: readonly ["srcSet"];
-                                                    }];
+                                                groupTranslationKey: {
+                                                    type: "string";
                                                 };
-                                                readonly separator: {
-                                                    readonly type: "string";
+                                                separator: {
+                                                    type: "string";
                                                 };
-                                                readonly separatorLine: {
-                                                    readonly type: "boolean";
+                                                separatorLine: {
+                                                    type: "boolean";
                                                 };
-                                                readonly linePosition: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["top", "bottom"];
-                                                    readonly default: "top";
+                                                linePosition: {
+                                                    type: "string";
+                                                    enum: ("top" | "bottom")[];
                                                 };
-                                                readonly version: {
-                                                    readonly type: "string";
+                                                version: {
+                                                    type: "string";
                                                 };
-                                                readonly menuStyle: {
-                                                    readonly type: "string";
-                                                    readonly enum: readonly ["drilldown"];
+                                                menuStyle: {
+                                                    type: "string";
+                                                    enum: "drilldown"[];
                                                 };
-                                                readonly expanded: {
-                                                    readonly type: "string";
-                                                    readonly const: "always";
+                                                expanded: {
+                                                    type: "string";
+                                                    const: "always";
                                                 };
-                                                readonly selectFirstItemOnExpand: {
-                                                    readonly type: "boolean";
+                                                selectFirstItemOnExpand: {
+                                                    type: "boolean";
                                                 };
-                                                readonly flatten: {
-                                                    readonly type: "boolean";
+                                                flatten: {
+                                                    type: "boolean";
                                                 };
-                                                readonly linkedSidebars: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "string";
+                                                linkedSidebars: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "string";
                                                     };
                                                 };
                                             };
-                                            readonly type: "object";
                                         };
                                     };
-                                    readonly copyrightText: {
-                                        readonly type: "string";
-                                    };
-                                    readonly logo: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    logo: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
+                                        additionalProperties: false;
+                                    };
+                                    hide: {
+                                        type: "boolean";
+                                    };
+                                    copyrightText: {
+                                        type: "string";
                                     };
                                 };
-                                readonly additionalProperties: false;
+                                additionalProperties: false;
                             };
-                            readonly sidebar: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            sidebar: {
+                                type: "object";
+                                properties: {
+                                    hide: {
+                                        type: "boolean";
                                     };
-                                    readonly separatorLine: {
-                                        readonly type: "boolean";
+                                    separatorLine: {
+                                        type: "boolean";
                                     };
-                                    readonly linePosition: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["top", "bottom"];
-                                        readonly default: "bottom";
+                                    linePosition: {
+                                        type: "string";
+                                        enum: ("top" | "bottom")[];
                                     };
                                 };
-                                readonly additionalProperties: false;
+                                additionalProperties: false;
                             };
-                            readonly scripts: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly head: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly src: {
-                                                    readonly type: "string";
+                            scripts: {
+                                type: "object";
+                                properties: {
+                                    head: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                type: {
+                                                    type: "string";
                                                 };
-                                                readonly async: {
-                                                    readonly type: "boolean";
+                                                src: {
+                                                    type: "string";
                                                 };
-                                                readonly crossorigin: {
-                                                    readonly type: "string";
+                                                crossorigin: {
+                                                    type: "string";
                                                 };
-                                                readonly defer: {
-                                                    readonly type: "boolean";
+                                                fetchpriority: {
+                                                    type: "string";
                                                 };
-                                                readonly fetchpriority: {
-                                                    readonly type: "string";
+                                                integrity: {
+                                                    type: "string";
                                                 };
-                                                readonly integrity: {
-                                                    readonly type: "string";
+                                                referrerpolicy: {
+                                                    type: "string";
                                                 };
-                                                readonly module: {
-                                                    readonly type: "boolean";
+                                                async: {
+                                                    type: "boolean";
                                                 };
-                                                readonly nomodule: {
-                                                    readonly type: "boolean";
+                                                defer: {
+                                                    type: "boolean";
                                                 };
-                                                readonly nonce: {
-                                                    readonly type: "string";
+                                                module: {
+                                                    type: "boolean";
                                                 };
-                                                readonly referrerpolicy: {
-                                                    readonly type: "string";
+                                                nomodule: {
+                                                    type: "boolean";
                                                 };
-                                                readonly type: {
-                                                    readonly type: "string";
+                                                nonce: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly required: readonly ["src"];
-                                            readonly additionalProperties: true;
+                                            additionalProperties: true;
+                                            required: "src"[];
                                         };
                                     };
-                                    readonly body: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly src: {
-                                                    readonly type: "string";
+                                    body: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                type: {
+                                                    type: "string";
                                                 };
-                                                readonly async: {
-                                                    readonly type: "boolean";
+                                                src: {
+                                                    type: "string";
                                                 };
-                                                readonly crossorigin: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly defer: {
-                                                    readonly type: "boolean";
-                                                };
-                                                readonly fetchpriority: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly integrity: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly module: {
-                                                    readonly type: "boolean";
-                                                };
-                                                readonly nomodule: {
-                                                    readonly type: "boolean";
-                                                };
-                                                readonly nonce: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly referrerpolicy: {
-                                                    readonly type: "string";
+                                                crossorigin: {
+                                                    type: "string";
                                                 };
-                                                readonly type: {
-                                                    readonly type: "string";
-                                                };
-                                            };
-                                            readonly required: readonly ["src"];
-                                            readonly additionalProperties: true;
-                                        };
-                                    };
-                                };
-                                readonly additionalProperties: false;
-                            };
-                            readonly links: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "object";
-                                    readonly properties: {
-                                        readonly href: {
-                                            readonly type: "string";
-                                        };
-                                        readonly as: {
-                                            readonly type: "string";
-                                        };
-                                        readonly crossorigin: {
-                                            readonly type: "string";
-                                        };
-                                        readonly fetchpriority: {
-                                            readonly type: "string";
-                                        };
-                                        readonly hreflang: {
-                                            readonly type: "string";
-                                        };
-                                        readonly imagesizes: {
-                                            readonly type: "string";
-                                        };
-                                        readonly imagesrcset: {
-                                            readonly type: "string";
-                                        };
-                                        readonly integrity: {
-                                            readonly type: "string";
-                                        };
-                                        readonly media: {
-                                            readonly type: "string";
-                                        };
-                                        readonly prefetch: {
-                                            readonly type: "string";
-                                        };
-                                        readonly referrerpolicy: {
-                                            readonly type: "string";
-                                        };
-                                        readonly rel: {
-                                            readonly type: "string";
-                                        };
-                                        readonly sizes: {
-                                            readonly type: "string";
-                                        };
-                                        readonly title: {
-                                            readonly type: "string";
-                                        };
-                                        readonly type: {
-                                            readonly type: "string";
-                                        };
-                                    };
-                                    readonly required: readonly ["href"];
-                                    readonly additionalProperties: true;
-                                };
-                            };
-                            readonly feedback: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
-                                        readonly default: false;
-                                    };
-                                    readonly type: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["rating", "sentiment", "comment", "reasons", "mood", "scale"];
-                                        readonly default: "sentiment";
-                                    };
-                                    readonly settings: {
-                                        readonly hide: {
-                                            readonly type: "boolean";
-                                        };
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly label: {
-                                                readonly type: "string";
-                                            };
-                                            readonly submitText: {
-                                                readonly type: "string";
-                                            };
-                                            readonly buttonText: {
-                                                readonly type: "string";
-                                            };
-                                            readonly component: {
-                                                readonly type: "string";
-                                                readonly enum: readonly ["radio", "checkbox"];
-                                                readonly default: "checkbox";
-                                            };
-                                            readonly items: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "string";
+                                                fetchpriority: {
+                                                    type: "string";
+                                                };
+                                                integrity: {
+                                                    type: "string";
+                                                };
+                                                referrerpolicy: {
+                                                    type: "string";
+                                                };
+                                                async: {
+                                                    type: "boolean";
+                                                };
+                                                defer: {
+                                                    type: "boolean";
+                                                };
+                                                module: {
+                                                    type: "boolean";
+                                                };
+                                                nomodule: {
+                                                    type: "boolean";
+                                                };
+                                                nonce: {
+                                                    type: "string";
                                                 };
-                                                readonly minItems: 1;
-                                            };
-                                            readonly leftScaleLabel: {
-                                                readonly type: "string";
-                                            };
-                                            readonly rightScaleLabel: {
-                                                readonly type: "string";
                                             };
-                                            readonly reasons: {
-                                                readonly type: "object";
-                                                readonly properties: {
-                                                    readonly hide: {
-                                                        readonly type: "boolean";
-                                                        readonly default: false;
+                                            additionalProperties: true;
+                                            required: "src"[];
+                                        };
+                                    };
+                                };
+                                additionalProperties: false;
+                            };
+                            feedback: {
+                                type: "object";
+                                properties: {
+                                    type: {
+                                        type: "string";
+                                        enum: ("rating" | "sentiment" | "comment" | "reasons" | "mood" | "scale")[];
+                                    };
+                                    hide: {
+                                        type: "boolean";
+                                    };
+                                    settings: {
+                                        type: "object";
+                                        properties: {
+                                            comment: {
+                                                type: "object";
+                                                properties: {
+                                                    hide: {
+                                                        type: "boolean";
                                                     };
-                                                    readonly component: {
-                                                        readonly type: "string";
-                                                        readonly enum: readonly ["radio", "checkbox"];
-                                                        readonly default: "checkbox";
+                                                    label: {
+                                                        type: "string";
                                                     };
-                                                    readonly label: {
-                                                        readonly type: "string";
+                                                    likeLabel: {
+                                                        type: "string";
                                                     };
-                                                    readonly items: {
-                                                        readonly type: "array";
-                                                        readonly items: {
-                                                            readonly type: "string";
-                                                        };
+                                                    dislikeLabel: {
+                                                        type: "string";
                                                     };
-                                                };
-                                                readonly additionalProperties: false;
-                                            };
-                                            readonly comment: {
-                                                readonly type: "object";
-                                                readonly properties: {
-                                                    readonly hide: {
-                                                        readonly type: "boolean";
-                                                        readonly default: false;
+                                                    satisfiedLabel: {
+                                                        type: "string";
                                                     };
-                                                    readonly label: {
-                                                        readonly type: "string";
+                                                    neutralLabel: {
+                                                        type: "string";
                                                     };
-                                                    readonly likeLabel: {
-                                                        readonly type: "string";
+                                                    dissatisfiedLabel: {
+                                                        type: "string";
                                                     };
-                                                    readonly dislikeLabel: {
-                                                        readonly type: "string";
+                                                };
+                                                additionalProperties: false;
+                                            };
+                                            reasons: {
+                                                type: "object";
+                                                properties: {
+                                                    items: {
+                                                        type: "array";
+                                                        items: {
+                                                            type: "string";
+                                                        };
                                                     };
-                                                    readonly satisfiedLabel: {
-                                                        readonly type: "string";
+                                                    hide: {
+                                                        type: "boolean";
                                                     };
-                                                    readonly neutralLabel: {
-                                                        readonly type: "string";
+                                                    label: {
+                                                        type: "string";
                                                     };
-                                                    readonly dissatisfiedLabel: {
-                                                        readonly type: "string";
+                                                    component: {
+                                                        type: "string";
+                                                        enum: ("radio" | "checkbox")[];
                                                     };
                                                 };
-                                                readonly additionalProperties: false;
+                                                additionalProperties: false;
+                                            };
+                                            items: {
+                                                type: "array";
+                                                items: {
+                                                    type: "string";
+                                                };
+                                                minItems: 1;
+                                            };
+                                            label: {
+                                                type: "string";
+                                            };
+                                            submitText: {
+                                                type: "string";
+                                            };
+                                            buttonText: {
+                                                type: "string";
+                                            };
+                                            component: {
+                                                type: "string";
+                                                enum: ("radio" | "checkbox")[];
+                                            };
+                                            leftScaleLabel: {
+                                                type: "string";
+                                            };
+                                            rightScaleLabel: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
+                                        additionalProperties: false;
+                                        hide: {
+                                            type: "boolean";
+                                        };
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly search: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            search: {
+                                type: "object";
+                                properties: {
+                                    hide: {
+                                        type: "boolean";
                                     };
-                                    readonly placement: {
-                                        readonly type: "string";
-                                        readonly default: "navbar";
+                                    placement: {
+                                        type: "string";
                                     };
-                                    readonly shortcuts: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    shortcuts: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
-                                        readonly default: readonly ["/"];
                                     };
-                                    readonly suggestedPages: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly page: {
-                                                    readonly type: "string";
+                                    suggestedPages: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                page: {
+                                                    type: "string";
                                                 };
-                                                readonly label: {
-                                                    readonly type: "string";
+                                                label: {
+                                                    type: "string";
                                                 };
-                                                readonly labelTranslationKey: {
-                                                    readonly type: "string";
+                                                labelTranslationKey: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly required: readonly ["page"];
+                                            required: "page"[];
                                         };
                                     };
-                                    readonly fuzzy: {
-                                        readonly type: "boolean";
-                                        readonly default: false;
+                                    fuzzy: {
+                                        type: "boolean";
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly colorMode: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            colorMode: {
+                                type: "object";
+                                properties: {
+                                    hide: {
+                                        type: "boolean";
                                     };
-                                    readonly ignoreDetection: {
-                                        readonly type: "boolean";
+                                    ignoreDetection: {
+                                        type: "boolean";
                                     };
-                                    readonly modes: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    modes: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
-                                        readonly default: readonly ["light", "dark"];
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly navigation: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly nextButton: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                            navigation: {
+                                type: "object";
+                                properties: {
+                                    nextButton: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly text: {
-                                                readonly type: "string";
-                                                readonly default: "Next to {{label}}";
+                                            text: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {};
+                                        additionalProperties: false;
                                     };
-                                    readonly previousButton: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    previousButton: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly text: {
-                                                readonly type: "string";
-                                                readonly default: "Back to {{label}}";
+                                            text: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {};
+                                        additionalProperties: false;
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly codeSnippet: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly elementFormat: {
-                                        readonly type: "string";
-                                        readonly default: "icon";
+                            codeSnippet: {
+                                type: "object";
+                                properties: {
+                                    elementFormat: {
+                                        type: "string";
                                     };
-                                    readonly copy: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    copy: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {
-                                            readonly hide: false;
-                                        };
+                                        additionalProperties: false;
                                     };
-                                    readonly report: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    report: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly tooltipText: {
-                                                readonly type: "string";
+                                            label: {
+                                                type: "string";
                                             };
-                                            readonly buttonText: {
-                                                readonly type: "string";
+                                            buttonText: {
+                                                type: "string";
                                             };
-                                            readonly label: {
-                                                readonly type: "string";
+                                            tooltipText: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {
-                                            readonly hide: false;
-                                        };
+                                        additionalProperties: false;
                                     };
-                                    readonly expand: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    expand: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {
-                                            readonly hide: false;
-                                        };
+                                        additionalProperties: false;
                                     };
-                                    readonly collapse: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    collapse: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {
-                                            readonly hide: false;
-                                        };
+                                        additionalProperties: false;
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly markdown: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly frontMatterKeysToResolve: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                            markdown: {
+                                type: "object";
+                                properties: {
+                                    frontMatterKeysToResolve: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
-                                        readonly default: readonly ["image", "links"];
                                     };
-                                    readonly partialsFolders: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
+                                    partialsFolders: {
+                                        type: "array";
+                                        items: {
+                                            type: "string";
                                         };
-                                        readonly default: readonly ["_partials"];
                                     };
-                                    readonly lastUpdatedBlock: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    lastUpdatedBlock: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly format: {
-                                                readonly type: "string";
-                                                readonly enum: readonly ["timeago", "iso", "long", "short"];
-                                                readonly default: "timeago";
+                                            format: {
+                                                type: "string";
+                                                enum: ("timeago" | "iso" | "long" | "short")[];
                                             };
-                                            readonly locale: {
-                                                readonly type: "string";
+                                            locale: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {};
+                                        additionalProperties: false;
                                     };
-                                    readonly toc: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    toc: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly header: {
-                                                readonly type: "string";
-                                                readonly default: "On this page";
+                                            header: {
+                                                type: "string";
                                             };
-                                            readonly depth: {
-                                                readonly type: "integer";
-                                                readonly default: 3;
-                                                readonly minimum: 1;
+                                            depth: {
+                                                type: "integer";
+                                                minimum: 1;
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {};
+                                        additionalProperties: false;
                                     };
-                                    readonly editPage: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly hide: {
-                                                readonly type: "boolean";
+                                    editPage: {
+                                        type: "object";
+                                        properties: {
+                                            hide: {
+                                                type: "boolean";
                                             };
-                                            readonly baseUrl: {
-                                                readonly type: "string";
+                                            baseUrl: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly default: {};
+                                        additionalProperties: false;
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
-                            };
-                            readonly openapi: {
-                                readonly type: "object";
-                                readonly additionalProperties: true;
-                            };
-                            readonly graphql: {
-                                readonly type: "object";
-                                readonly additionalProperties: true;
+                                additionalProperties: false;
                             };
-                            readonly analytics: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly adobe: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                            analytics: {
+                                type: "object";
+                                properties: {
+                                    adobe: {
+                                        type: "object";
+                                        properties: {
+                                            scriptUrl: {
+                                                type: "string";
                                             };
-                                            readonly scriptUrl: {
-                                                readonly type: "string";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly pageViewEventName: {
-                                                readonly type: "string";
+                                            pageViewEventName: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["scriptUrl"];
+                                        additionalProperties: false;
+                                        required: "scriptUrl"[];
                                     };
-                                    readonly amplitude: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    amplitude: {
+                                        type: "object";
+                                        properties: {
+                                            apiKey: {
+                                                type: "string";
                                             };
-                                            readonly apiKey: {
-                                                readonly type: "string";
+                                            head: {
+                                                type: "boolean";
                                             };
-                                            readonly head: {
-                                                readonly type: "boolean";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly respectDNT: {
-                                                readonly type: "boolean";
+                                            pageViewEventName: {
+                                                type: "string";
                                             };
-                                            readonly exclude: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "string";
-                                                };
+                                            respectDNT: {
+                                                type: "boolean";
                                             };
-                                            readonly outboundClickEventName: {
-                                                readonly type: "string";
+                                            exclude: {
+                                                type: "array";
+                                                items: {
+                                                    type: "string";
+                                                };
                                             };
-                                            readonly pageViewEventName: {
-                                                readonly type: "string";
+                                            outboundClickEventName: {
+                                                type: "string";
                                             };
-                                            readonly amplitudeConfig: {
-                                                readonly type: "object";
-                                                readonly additionalProperties: true;
+                                            amplitudeConfig: {
+                                                type: "object";
+                                                additionalProperties: true;
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["apiKey"];
+                                        additionalProperties: false;
+                                        required: "apiKey"[];
                                     };
-                                    readonly fullstory: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    fullstory: {
+                                        type: "object";
+                                        properties: {
+                                            orgId: {
+                                                type: "string";
                                             };
-                                            readonly orgId: {
-                                                readonly type: "string";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["orgId"];
+                                        additionalProperties: false;
+                                        required: "orgId"[];
                                     };
-                                    readonly heap: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    heap: {
+                                        type: "object";
+                                        properties: {
+                                            appId: {
+                                                type: "string";
                                             };
-                                            readonly appId: {
-                                                readonly type: "string";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["appId"];
+                                        additionalProperties: false;
+                                        required: "appId"[];
                                     };
-                                    readonly rudderstack: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    rudderstack: {
+                                        type: "object";
+                                        properties: {
+                                            writeKey: {
+                                                type: "string";
+                                                minLength: 10;
                                             };
-                                            readonly writeKey: {
-                                                readonly type: "string";
-                                                readonly minLength: 10;
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly trackPage: {
-                                                readonly type: "boolean";
+                                            trackPage: {
+                                                type: "boolean";
                                             };
-                                            readonly dataPlaneUrl: {
-                                                readonly type: "string";
+                                            dataPlaneUrl: {
+                                                type: "string";
                                             };
-                                            readonly controlPlaneUrl: {
-                                                readonly type: "string";
+                                            controlPlaneUrl: {
+                                                type: "string";
                                             };
-                                            readonly sdkUrl: {
-                                                readonly type: "string";
+                                            sdkUrl: {
+                                                type: "string";
                                             };
-                                            readonly loadOptions: {
-                                                readonly type: "object";
-                                                readonly additionalProperties: true;
+                                            loadOptions: {
+                                                type: "object";
+                                                additionalProperties: true;
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["writeKey"];
+                                        additionalProperties: false;
+                                        required: "writeKey"[];
                                     };
-                                    readonly segment: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    segment: {
+                                        type: "object";
+                                        properties: {
+                                            writeKey: {
+                                                type: "string";
+                                                minLength: 10;
                                             };
-                                            readonly writeKey: {
-                                                readonly type: "string";
-                                                readonly minLength: 10;
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly trackPage: {
-                                                readonly type: "boolean";
+                                            trackPage: {
+                                                type: "boolean";
                                             };
-                                            readonly includeTitleInPageCall: {
-                                                readonly type: "boolean";
+                                            includeTitleInPageCall: {
+                                                type: "boolean";
                                             };
-                                            readonly host: {
-                                                readonly type: "string";
+                                            host: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["writeKey"];
+                                        additionalProperties: false;
+                                        required: "writeKey"[];
                                     };
-                                    readonly gtm: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    gtm: {
+                                        type: "object";
+                                        properties: {
+                                            trackingId: {
+                                                type: "string";
                                             };
-                                            readonly trackingId: {
-                                                readonly type: "string";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly gtmAuth: {
-                                                readonly type: "string";
+                                            pageViewEventName: {
+                                                type: "string";
                                             };
-                                            readonly gtmPreview: {
-                                                readonly type: "string";
+                                            gtmAuth: {
+                                                type: "string";
                                             };
-                                            readonly defaultDataLayer: {};
-                                            readonly dataLayerName: {
-                                                readonly type: "string";
+                                            gtmPreview: {
+                                                type: "string";
                                             };
-                                            readonly enableWebVitalsTracking: {
-                                                readonly type: "boolean";
+                                            defaultDataLayer: {};
+                                            dataLayerName: {
+                                                type: "string";
                                             };
-                                            readonly selfHostedOrigin: {
-                                                readonly type: "string";
+                                            enableWebVitalsTracking: {
+                                                type: "boolean";
                                             };
-                                            readonly pageViewEventName: {
-                                                readonly type: "string";
+                                            selfHostedOrigin: {
+                                                type: "string";
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["trackingId"];
+                                        additionalProperties: false;
+                                        required: "trackingId"[];
                                     };
-                                    readonly ga: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly includeInDevelopment: {
-                                                readonly type: "boolean";
+                                    ga: {
+                                        type: "object";
+                                        properties: {
+                                            trackingId: {
+                                                type: "string";
                                             };
-                                            readonly trackingId: {
-                                                readonly type: "string";
+                                            head: {
+                                                type: "boolean";
                                             };
-                                            readonly conversionId: {
-                                                readonly type: "string";
+                                            includeInDevelopment: {
+                                                type: "boolean";
                                             };
-                                            readonly floodlightId: {
-                                                readonly type: "string";
+                                            respectDNT: {
+                                                type: "boolean";
                                             };
-                                            readonly head: {
-                                                readonly type: "boolean";
+                                            exclude: {
+                                                type: "array";
+                                                items: {
+                                                    type: "string";
+                                                };
                                             };
-                                            readonly respectDNT: {
-                                                readonly type: "boolean";
+                                            conversionId: {
+                                                type: "string";
                                             };
-                                            readonly exclude: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "string";
-                                                };
+                                            floodlightId: {
+                                                type: "string";
                                             };
-                                            readonly optimizeId: {
-                                                readonly type: "string";
+                                            optimizeId: {
+                                                type: "string";
                                             };
-                                            readonly anonymizeIp: {
-                                                readonly type: "boolean";
+                                            anonymizeIp: {
+                                                type: "boolean";
                                             };
-                                            readonly cookieExpires: {
-                                                readonly type: "number";
+                                            cookieExpires: {
+                                                type: "number";
                                             };
-                                            readonly trackers: {
-                                                readonly type: "object";
-                                                readonly additionalProperties: {
-                                                    readonly type: "object";
-                                                    readonly properties: {
-                                                        readonly includeInDevelopment: {
-                                                            readonly type: "boolean";
+                                            trackers: {
+                                                type: "object";
+                                                additionalProperties: {
+                                                    type: "object";
+                                                    properties: {
+                                                        trackingId: {
+                                                            type: "string";
                                                         };
-                                                        readonly trackingId: {
-                                                            readonly type: "string";
+                                                        includeInDevelopment: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly conversionId: {
-                                                            readonly type: "string";
+                                                        exclude: {
+                                                            type: "array";
+                                                            items: any;
                                                         };
-                                                        readonly floodlightId: {
-                                                            readonly type: "string";
+                                                        conversionId: {
+                                                            type: "string";
                                                         };
-                                                        readonly optimizeId: {
-                                                            readonly type: "string";
+                                                        floodlightId: {
+                                                            type: "string";
                                                         };
-                                                        readonly exclude: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "string";
-                                                            };
+                                                        optimizeId: {
+                                                            type: "string";
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["trackingId"];
+                                                    additionalProperties: false;
+                                                    required: "trackingId"[];
                                                 };
                                             };
                                         };
-                                        readonly additionalProperties: false;
-                                        readonly required: readonly ["trackingId"];
+                                        additionalProperties: false;
+                                        required: "trackingId"[];
                                     };
                                 };
                             };
-                            readonly userProfile: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
-                                    };
-                                    readonly loginLabel: {
-                                        readonly type: "string";
-                                        readonly default: "Login";
-                                    };
-                                    readonly logoutLabel: {
-                                        readonly type: "string";
-                                        readonly default: "Logout";
-                                    };
-                                    readonly menu: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly label: {
-                                                    readonly type: "string";
+                            userMenu: {
+                                type: "object";
+                                properties: {
+                                    items: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                label: {
+                                                    type: "string";
                                                 };
-                                                readonly external: {
-                                                    readonly type: "boolean";
+                                                external: {
+                                                    type: "boolean";
                                                 };
-                                                readonly link: {
-                                                    readonly type: "string";
+                                                separatorLine: {
+                                                    type: "boolean";
                                                 };
-                                                readonly separatorLine: {
-                                                    readonly type: "boolean";
+                                                link: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly additionalProperties: true;
+                                            additionalProperties: true;
                                         };
-                                        readonly default: readonly [];
+                                    };
+                                    hide: {
+                                        type: "boolean";
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly versionPicker: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            versionPicker: {
+                                type: "object";
+                                properties: {
+                                    hide: {
+                                        type: "boolean";
                                     };
-                                    readonly showForUnversioned: {
-                                        readonly type: "boolean";
+                                    showForUnversioned: {
+                                        type: "boolean";
                                     };
                                 };
                             };
-                            readonly breadcrumbs: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly hide: {
-                                        readonly type: "boolean";
+                            breadcrumbs: {
+                                type: "object";
+                                properties: {
+                                    hide: {
+                                        type: "boolean";
                                     };
-                                    readonly prefixItems: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly label: {
-                                                    readonly type: "string";
+                                    prefixItems: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                page: {
+                                                    type: "string";
                                                 };
-                                                readonly labelTranslationKey: {
-                                                    readonly type: "string";
+                                                label: {
+                                                    type: "string";
                                                 };
-                                                readonly page: {
-                                                    readonly type: "string";
+                                                labelTranslationKey: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly additionalProperties: false;
-                                            readonly default: {};
+                                            additionalProperties: false;
                                         };
                                     };
                                 };
-                                readonly additionalProperties: false;
-                                readonly default: {};
+                                additionalProperties: false;
                             };
-                            readonly catalog: {
-                                readonly type: "object";
-                                readonly patternProperties: {
-                                    readonly '.*': {
-                                        readonly type: "object";
-                                        readonly additionalProperties: true;
-                                        readonly required: readonly ["slug", "items"];
-                                        readonly properties: {
-                                            readonly slug: {
-                                                readonly type: "string";
+                            catalog: {
+                                type: "object";
+                                patternProperties: {
+                                    ".*": {
+                                        type: "object";
+                                        properties: {
+                                            slug: {
+                                                type: "string";
                                             };
-                                            readonly filters: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly type: "object";
-                                                    readonly additionalProperties: false;
-                                                    readonly required: readonly ["title", "property"];
-                                                    readonly properties: {
-                                                        readonly type: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["select", "checkboxes", "date-range"];
-                                                        };
-                                                        readonly title: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly titleTranslationKey: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly property: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly parentFilter: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly valuesMapping: {
-                                                            readonly type: "object";
-                                                            readonly additionalProperties: {
-                                                                readonly type: "string";
-                                                            };
+                                            items: {
+                                                type: "array";
+                                                items: {
+                                                    type: "object";
+                                                    properties: {
+                                                        href: {
+                                                            type: "string";
                                                         };
-                                                        readonly missingCategoryName: {
-                                                            readonly type: "string";
-                                                        };
-                                                        readonly missingCategoryNameTranslationKey: {
-                                                            readonly type: "string";
+                                                        page: {
+                                                            type: "string";
                                                         };
-                                                        readonly options: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "string";
-                                                            };
+                                                        icon: {
+                                                            oneOf: ({
+                                                                type: "string";
+                                                            } | {
+                                                                type: "object";
+                                                                properties: {
+                                                                    srcSet: any;
+                                                                };
+                                                                required: "srcSet"[];
+                                                            })[];
                                                         };
-                                                    };
-                                                };
-                                            };
-                                            readonly groupByFirstFilter: {
-                                                readonly type: "boolean";
-                                            };
-                                            readonly filterValuesCasing: {
-                                                readonly type: "string";
-                                                readonly enum: readonly ["sentence", "original", "lowercase", "uppercase"];
-                                            };
-                                            readonly items: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly properties: {
-                                                        readonly items: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly page: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly directory: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly disconnect: {
-                                                                        readonly type: "boolean";
-                                                                        readonly default: false;
+                                                        items: {
+                                                            type: "array";
+                                                            items: {
+                                                                type: "object";
+                                                                properties: {
+                                                                    href: {
+                                                                        type: "string";
                                                                     };
-                                                                    readonly group: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly label: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly href: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly external: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly labelTranslationKey: {
-                                                                        readonly type: "string";
+                                                                    page: {
+                                                                        type: "string";
                                                                     };
-                                                                    readonly groupTranslationKey: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly icon: {
-                                                                        readonly oneOf: readonly [{
-                                                                            readonly type: "string";
-                                                                        }, {
-                                                                            readonly type: "object";
-                                                                            readonly properties: {
-                                                                                readonly srcSet: {
-                                                                                    readonly type: "string";
-                                                                                };
+                                                                    icon: {
+                                                                        oneOf: ({
+                                                                            type: "string";
+                                                                        } | {
+                                                                            type: "object";
+                                                                            properties: {
+                                                                                srcSet: any;
                                                                             };
-                                                                            readonly required: readonly ["srcSet"];
-                                                                        }];
-                                                                    };
-                                                                    readonly separator: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly separatorLine: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly linePosition: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["top", "bottom"];
-                                                                        readonly default: "top";
-                                                                    };
-                                                                    readonly version: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                    readonly menuStyle: {
-                                                                        readonly type: "string";
-                                                                        readonly enum: readonly ["drilldown"];
-                                                                    };
-                                                                    readonly expanded: {
-                                                                        readonly type: "string";
-                                                                        readonly const: "always";
-                                                                    };
-                                                                    readonly selectFirstItemOnExpand: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly flatten: {
-                                                                        readonly type: "boolean";
-                                                                    };
-                                                                    readonly linkedSidebars: {
-                                                                        readonly type: "array";
-                                                                        readonly items: {
-                                                                            readonly type: "string";
-                                                                        };
-                                                                    };
-                                                                    readonly items: {
-                                                                        readonly type: "array";
-                                                                        readonly items: {
-                                                                            readonly type: "object";
-                                                                            readonly additionalProperties: true;
-                                                                        };
+                                                                            required: "srcSet"[];
+                                                                        })[];
                                                                     };
+                                                                    items: any;
+                                                                    directory: any;
+                                                                    disconnect: any;
+                                                                    group: any;
+                                                                    label: any;
+                                                                    external: any;
+                                                                    labelTranslationKey: any;
+                                                                    groupTranslationKey: any;
+                                                                    separator: any;
+                                                                    separatorLine: any;
+                                                                    linePosition: any;
+                                                                    version: any;
+                                                                    menuStyle: any;
+                                                                    expanded: any;
+                                                                    selectFirstItemOnExpand: any;
+                                                                    flatten: any;
+                                                                    linkedSidebars: any;
                                                                 };
                                                             };
                                                         };
-                                                        readonly page: {
-                                                            readonly type: "string";
+                                                        directory: {
+                                                            type: "string";
                                                         };
-                                                        readonly directory: {
-                                                            readonly type: "string";
+                                                        disconnect: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly disconnect: {
-                                                            readonly type: "boolean";
-                                                            readonly default: false;
+                                                        group: {
+                                                            type: "string";
                                                         };
-                                                        readonly group: {
-                                                            readonly type: "string";
+                                                        label: {
+                                                            type: "string";
                                                         };
-                                                        readonly label: {
-                                                            readonly type: "string";
+                                                        external: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly href: {
-                                                            readonly type: "string";
+                                                        labelTranslationKey: {
+                                                            type: "string";
                                                         };
-                                                        readonly external: {
-                                                            readonly type: "boolean";
+                                                        groupTranslationKey: {
+                                                            type: "string";
                                                         };
-                                                        readonly labelTranslationKey: {
-                                                            readonly type: "string";
+                                                        separator: {
+                                                            type: "string";
                                                         };
-                                                        readonly groupTranslationKey: {
-                                                            readonly type: "string";
+                                                        separatorLine: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly icon: {
-                                                            readonly oneOf: readonly [{
-                                                                readonly type: "string";
-                                                            }, {
-                                                                readonly type: "object";
-                                                                readonly properties: {
-                                                                    readonly srcSet: {
-                                                                        readonly type: "string";
-                                                                    };
-                                                                };
-                                                                readonly required: readonly ["srcSet"];
-                                                            }];
+                                                        linePosition: {
+                                                            type: "string";
+                                                            enum: ("top" | "bottom")[];
                                                         };
-                                                        readonly separator: {
-                                                            readonly type: "string";
+                                                        version: {
+                                                            type: "string";
                                                         };
-                                                        readonly separatorLine: {
-                                                            readonly type: "boolean";
+                                                        menuStyle: {
+                                                            type: "string";
+                                                            enum: "drilldown"[];
                                                         };
-                                                        readonly linePosition: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["top", "bottom"];
-                                                            readonly default: "top";
+                                                        expanded: {
+                                                            type: "string";
+                                                            const: "always";
                                                         };
-                                                        readonly version: {
-                                                            readonly type: "string";
+                                                        selectFirstItemOnExpand: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly menuStyle: {
-                                                            readonly type: "string";
-                                                            readonly enum: readonly ["drilldown"];
+                                                        flatten: {
+                                                            type: "boolean";
                                                         };
-                                                        readonly expanded: {
-                                                            readonly type: "string";
-                                                            readonly const: "always";
+                                                        linkedSidebars: {
+                                                            type: "array";
+                                                            items: {
+                                                                type: "string";
+                                                            };
                                                         };
-                                                        readonly selectFirstItemOnExpand: {
-                                                            readonly type: "boolean";
+                                                    };
+                                                };
+                                            };
+                                            title: {
+                                                type: "string";
+                                            };
+                                            description: {
+                                                type: "string";
+                                            };
+                                            filters: {
+                                                type: "array";
+                                                items: {
+                                                    type: "object";
+                                                    properties: {
+                                                        type: {
+                                                            type: "string";
+                                                            enum: ("select" | "checkboxes" | "date-range")[];
                                                         };
-                                                        readonly flatten: {
-                                                            readonly type: "boolean";
+                                                        title: {
+                                                            type: "string";
                                                         };
-                                                        readonly linkedSidebars: {
-                                                            readonly type: "array";
-                                                            readonly items: {
-                                                                readonly type: "string";
-                                                            };
+                                                        property: {
+                                                            type: "string";
+                                                        };
+                                                        titleTranslationKey: {
+                                                            type: "string";
+                                                        };
+                                                        parentFilter: {
+                                                            type: "string";
+                                                        };
+                                                        valuesMapping: {
+                                                            type: "object";
+                                                            additionalProperties: any;
+                                                        };
+                                                        missingCategoryName: {
+                                                            type: "string";
+                                                        };
+                                                        missingCategoryNameTranslationKey: {
+                                                            type: "string";
+                                                        };
+                                                        options: {
+                                                            type: "array";
+                                                            items: any;
                                                         };
                                                     };
-                                                    readonly type: "object";
+                                                    additionalProperties: false;
+                                                    required: ("title" | "property")[];
                                                 };
                                             };
-                                            readonly requiredPermission: {
-                                                readonly type: "string";
+                                            groupByFirstFilter: {
+                                                type: "boolean";
                                             };
-                                            readonly separateVersions: {
-                                                readonly type: "boolean";
+                                            filterValuesCasing: {
+                                                type: "string";
+                                                enum: ("sentence" | "original" | "lowercase" | "uppercase")[];
                                             };
-                                            readonly title: {
-                                                readonly type: "string";
+                                            requiredPermission: {
+                                                type: "string";
                                             };
-                                            readonly titleTranslationKey: {
-                                                readonly type: "string";
+                                            separateVersions: {
+                                                type: "boolean";
                                             };
-                                            readonly description: {
-                                                readonly type: "string";
+                                            titleTranslationKey: {
+                                                type: "string";
                                             };
-                                            readonly descriptionTranslationKey: {
-                                                readonly type: "string";
+                                            descriptionTranslationKey: {
+                                                type: "string";
                                             };
                                         };
+                                        additionalProperties: true;
+                                        required: ("slug" | "items")[];
                                     };
                                 };
                             };
-                            readonly scorecard: {
-                                readonly type: "object";
-                                readonly additionalProperties: true;
-                                readonly required: readonly [];
-                                readonly properties: {
-                                    readonly ignoreNonCompliant: {
-                                        readonly type: "boolean";
-                                        readonly default: false;
+                            scorecard: {
+                                type: "object";
+                                properties: {
+                                    ignoreNonCompliant: {
+                                        type: "boolean";
                                     };
-                                    readonly teamMetadataProperty: {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly property: {
-                                                readonly type: "string";
-                                            };
-                                            readonly label: {
-                                                readonly type: "string";
+                                    teamMetadataProperty: {
+                                        type: "object";
+                                        properties: {
+                                            property: {
+                                                type: "string";
                                             };
-                                            readonly default: {
-                                                readonly type: "string";
+                                            label: {
+                                                type: "string";
                                             };
                                         };
                                     };
-                                    readonly levels: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly required: readonly ["name"];
-                                            readonly properties: {
-                                                readonly name: {
-                                                    readonly type: "string";
+                                    levels: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                name: {
+                                                    type: "string";
                                                 };
-                                                readonly color: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly extends: {
-                                                    readonly type: "array";
-                                                    readonly items: {
-                                                        readonly type: "string";
+                                                rules: {
+                                                    type: "object";
+                                                    additionalProperties: {
+                                                        oneOf: ({
+                                                            type: "string";
+                                                        } | {
+                                                            type: "object";
+                                                        })[];
                                                     };
                                                 };
-                                                readonly rules: {
-                                                    readonly type: "object";
-                                                    readonly additionalProperties: {
-                                                        readonly oneOf: readonly [{
-                                                            readonly type: "string";
-                                                        }, {
-                                                            readonly type: "object";
-                                                        }];
+                                                color: {
+                                                    type: "string";
+                                                };
+                                                extends: {
+                                                    type: "array";
+                                                    items: {
+                                                        type: "string";
                                                     };
                                                 };
                                             };
-                                            readonly additionalProperties: false;
+                                            additionalProperties: false;
+                                            required: "name"[];
                                         };
                                     };
-                                    readonly targets: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "object";
-                                            readonly required: readonly ["where"];
-                                            readonly properties: {
-                                                readonly minimumLevel: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly where: {
-                                                    readonly type: "object";
-                                                    readonly required: readonly ["metadata"];
-                                                    readonly properties: {
-                                                        readonly metadata: {
-                                                            readonly type: "object";
-                                                            readonly additionalProperties: {
-                                                                readonly type: "string";
-                                                            };
+                                    targets: {
+                                        type: "array";
+                                        items: {
+                                            type: "object";
+                                            properties: {
+                                                where: {
+                                                    type: "object";
+                                                    properties: {
+                                                        metadata: {
+                                                            type: "object";
+                                                            additionalProperties: any;
                                                         };
                                                     };
-                                                    readonly additionalProperties: false;
+                                                    additionalProperties: false;
+                                                    required: "metadata"[];
+                                                };
+                                                minimumLevel: {
+                                                    type: "string";
                                                 };
                                             };
-                                            readonly additionalProperties: false;
+                                            additionalProperties: false;
+                                            required: "where"[];
                                         };
                                     };
                                 };
+                                additionalProperties: true;
+                                required: never[];
                             };
                         };
-                        readonly additionalProperties: true;
-                        readonly default: {};
+                        additionalProperties: true;
                     };
-                    readonly reunite: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly ignoreLinkChecker: {
-                                readonly type: "boolean";
+                    reunite: {
+                        type: "object";
+                        properties: {
+                            ignoreLinkChecker: {
+                                type: "boolean";
                             };
                         };
-                        readonly additionalProperties: false;
+                        additionalProperties: false;
                     };
                 };
-                readonly default: {
-                    readonly redirects: {};
-                };
             };
         };
         readonly licenseKey: {
@@ -5967,6 +5739,16 @@ export declare const rootRedoclyConfigSchema: {
                 readonly required: readonly ["root"];
             };
         };
+        readonly rules: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                }];
+            };
+        };
         readonly ssoOnPrem: {
             readonly type: "object";
             readonly additionalProperties: {
@@ -7165,7 +6947,7 @@ export declare const rootRedoclyConfigSchema: {
                                 };
                                 readonly text: {
                                     readonly type: "string";
-                                    readonly default: "Next to {{label}}";
+                                    readonly default: "Next page";
                                 };
                             };
                             readonly additionalProperties: false;
@@ -7179,7 +6961,7 @@ export declare const rootRedoclyConfigSchema: {
                                 };
                                 readonly text: {
                                     readonly type: "string";
-                                    readonly default: "Back to {{label}}";
+                                    readonly default: "Previous page";
                                 };
                             };
                             readonly additionalProperties: false;
@@ -7574,21 +7356,13 @@ export declare const rootRedoclyConfigSchema: {
                         };
                     };
                 };
-                readonly userProfile: {
+                readonly userMenu: {
                     readonly type: "object";
                     readonly properties: {
                         readonly hide: {
                             readonly type: "boolean";
                         };
-                        readonly loginLabel: {
-                            readonly type: "string";
-                            readonly default: "Login";
-                        };
-                        readonly logoutLabel: {
-                            readonly type: "string";
-                            readonly default: "Logout";
-                        };
-                        readonly menu: {
+                        readonly items: {
                             readonly type: "array";
                             readonly items: {
                                 readonly type: "object";
@@ -7675,6 +7449,7 @@ export declare const rootRedoclyConfigSchema: {
                                             readonly type: {
                                                 readonly type: "string";
                                                 readonly enum: readonly ["select", "checkboxes", "date-range"];
+                                                readonly default: "checkboxes";
                                             };
                                             readonly title: {
                                                 readonly type: "string";