---
url: /reference/@cssdoc/config/variables/cssDocSchema.md
---
# Variable: cssDocSchema

```ts
const cssDocSchema: object;
```

Defined in: [packages/config/src/schema.ts:10](https://github.com/thedannywahl/cssdoc/blob/main/packages/config/src/schema.ts#L10)

The JSON Schema (draft-07) describing a valid `cssdoc.json`.

## Type Declaration

### $id

```ts
readonly $id: "https://cssdoc.dev/cssdoc.schema.json" = "https://cssdoc.dev/cssdoc.schema.json";
```

### $schema

```ts
readonly $schema: "http://json-schema.org/draft-07/schema#" = "http://json-schema.org/draft-07/schema#";
```

### additionalProperties

```ts
readonly additionalProperties: false = false;
```

### description

```ts
readonly description: "Configuration for cssdoc: custom tags, lint rules, and markdown render options." = "Configuration for cssdoc: custom tags, lint rules, and markdown render options.";
```

### properties

```ts
readonly properties: object;
```

#### properties.$schema

```ts
readonly $schema: object;
```

#### properties.$schema.type

```ts
readonly type: "string" = "string";
```

#### properties.extends

```ts
readonly extends: object;
```

#### properties.extends.description

```ts
readonly description: "Paths to other cssdoc.json files (or packages) to inherit tag definitions from." = "Paths to other cssdoc.json files (or packages) to inherit tag definitions from.";
```

#### properties.extends.items

```ts
readonly items: object;
```

#### properties.extends.items.type

```ts
readonly type: "string" = "string";
```

#### properties.extends.type

```ts
readonly type: "array" = "array";
```

#### properties.globalPrecedence

```ts
readonly globalPrecedence: object;
```

#### properties.globalPrecedence.description

```ts
readonly description: "Precedence model when multiple records define the same modifier, with at least one marked @global: \"base\" (explicit modifiers override global; default) or \"global\" (global overrides explicit)." = 'Precedence model when multiple records define the same modifier, with at least one marked @global: "base" (explicit modifiers override global; default) or "global" (global overrides explicit).';
```

#### properties.globalPrecedence.enum

```ts
readonly enum: readonly ["base", "global"];
```

#### properties.inlineComments

```ts
readonly inlineComments: object;
```

#### properties.inlineComments.description

```ts
readonly description: "How a /* … */ comment on a member's rule combines with its tag prose: append (default), prepend, replace, or ignore." = "How a /* … */ comment on a member's rule combines with its tag prose: append (default), prepend, replace, or ignore.";
```

#### properties.inlineComments.enum

```ts
readonly enum: readonly ["append", "prepend", "replace", "ignore"];
```

#### properties.modifierConvention

```ts
readonly modifierConvention: object;
```

#### properties.modifierConvention.description

```ts
readonly description: "How modifier classes are spelled: a preset name (bem, rscss, bare) or a custom convention." = "How modifier classes are spelled: a preset name (bem, rscss, bare) or a custom convention.";
```

#### properties.modifierConvention.oneOf

```ts
readonly oneOf: readonly [{
  enum: readonly ["bem", "rscss", "bare"];
}, {
  additionalProperties: false;
  properties: {
     elementSeparator: {
        description: "BEM-style element delimiter (e.g. \"__\"); matched classes become parts.";
        oneOf: readonly [{
           type: "string";
         }, {
           items: {
              type: "string";
           };
           type: "array";
        }];
     };
     propValue: {
        type: "boolean";
     };
     propValueSeparator: {
        type: "string";
     };
     pseudoElements: {
        description: "Native pseudo-elements (without the ::) to document, e.g. [\"before\",\"after\"]. Overrides the built-in default set.";
        items: {
           type: "string";
        };
        type: "array";
     };
     separator: {
        oneOf: readonly [{
           type: "string";
         }, {
           items: {
              type: "string";
           };
           type: "array";
        }];
     };
     statePrefixes: {
        description: "Class prefixes that mark a state (e.g. [\"is-\",\"has-\"]).";
        items: {
           type: "string";
        };
        type: "array";
     };
     statePseudoClasses: {
        description: "Native pseudo-classes (without the colon) recognized as states, e.g. [\"disabled\",\"checked\"]. Overrides the built-in default set.";
        items: {
           type: "string";
        };
        type: "array";
     };
     structure: {
        enum: readonly ["chained", "suffix", "attribute"];
     };
  };
  required: readonly ["structure", "separator"];
  type: "object";
}];
```

#### properties.naming

```ts
readonly naming: object;
```

#### properties.naming.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.naming.description

```ts
readonly description: "Enforce a name case on class names: a preset (pascalCase, camelCase, lowercase) or a custom regex." = "Enforce a name case on class names: a preset (pascalCase, camelCase, lowercase) or a custom regex.";
```

#### properties.naming.properties

```ts
readonly properties: object;
```

#### properties.naming.properties.component

```ts
readonly component: object;
```

#### properties.naming.properties.component.type

```ts
readonly type: "string" = "string";
```

#### properties.naming.properties.part

```ts
readonly part: object;
```

#### properties.naming.properties.part.type

```ts
readonly type: "string" = "string";
```

#### properties.naming.type

```ts
readonly type: "object" = "object";
```

#### properties.noStandardTags

```ts
readonly noStandardTags: object;
```

#### properties.noStandardTags.description

```ts
readonly description: "Disable every built-in standard tag; only tagDefinitions remain supported." = "Disable every built-in standard tag; only tagDefinitions remain supported.";
```

#### properties.noStandardTags.type

```ts
readonly type: "boolean" = "boolean";
```

#### properties.overrides

```ts
readonly overrides: object;
```

#### properties.overrides.description

```ts
readonly description: "Per-glob rule severity overrides. Globs are relative to this config file." = "Per-glob rule severity overrides. Globs are relative to this config file.";
```

#### properties.overrides.items

```ts
readonly items: object;
```

#### properties.overrides.items.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.overrides.items.properties

```ts
readonly properties: object;
```

#### properties.overrides.items.properties.files

```ts
readonly files: object;
```

#### properties.overrides.items.properties.files.description

```ts
readonly description: "One or more glob patterns relative to this config file." = "One or more glob patterns relative to this config file.";
```

#### properties.overrides.items.properties.files.oneOf

```ts
readonly oneOf: readonly [{
  type: "string";
}, {
  items: {
     type: "string";
  };
  type: "array";
}];
```

#### properties.overrides.items.properties.rules

```ts
readonly rules: object;
```

#### properties.overrides.items.properties.rules.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.overrides.items.properties.rules.description

```ts
readonly description: "Per-rule severity overrides for matching files (off/warn/error)." = "Per-rule severity overrides for matching files (off/warn/error).";
```

#### properties.overrides.items.properties.rules.properties

```ts
readonly properties: object;
```

#### properties.overrides.items.properties.rules.properties.alias-requires-canonical

```ts
readonly alias-requires-canonical: object;
```

#### properties.overrides.items.properties.rules.properties.alias-requires-canonical.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.component-name-case

```ts
readonly component-name-case: object;
```

#### properties.overrides.items.properties.rules.properties.component-name-case.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.conflicting-global-modifier

```ts
readonly conflicting-global-modifier: object;
```

#### properties.overrides.items.properties.rules.properties.conflicting-global-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.cssdoc-directive

```ts
readonly cssdoc-directive: object;
```

#### properties.overrides.items.properties.rules.properties.cssdoc-directive.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.deprecated-modifier

```ts
readonly deprecated-modifier: object;
```

#### properties.overrides.items.properties.rules.properties.deprecated-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.deprecated-requires-canonical

```ts
readonly deprecated-requires-canonical: object;
```

#### properties.overrides.items.properties.rules.properties.deprecated-requires-canonical.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.disallowed-element

```ts
readonly disallowed-element: object;
```

#### properties.overrides.items.properties.rules.properties.disallowed-element.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.duplicate-record-id

```ts
readonly duplicate-record-id: object;
```

#### properties.overrides.items.properties.rules.properties.duplicate-record-id.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.duplicate-record-id-cross-kind

```ts
readonly duplicate-record-id-cross-kind: object;
```

#### properties.overrides.items.properties.rules.properties.duplicate-record-id-cross-kind.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.invalid-default-value

```ts
readonly invalid-default-value: object;
```

#### properties.overrides.items.properties.rules.properties.invalid-default-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.invalid-fallback-value

```ts
readonly invalid-fallback-value: object;
```

#### properties.overrides.items.properties.rules.properties.invalid-fallback-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.invalid-property-value

```ts
readonly invalid-property-value: object;
```

#### properties.overrides.items.properties.rules.properties.invalid-property-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.missing-summary

```ts
readonly missing-summary: object;
```

#### properties.overrides.items.properties.rules.properties.missing-summary.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.name-not-in-css

```ts
readonly name-not-in-css: object;
```

#### properties.overrides.items.properties.rules.properties.name-not-in-css.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.part-name-case

```ts
readonly part-name-case: object;
```

#### properties.overrides.items.properties.rules.properties.part-name-case.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.readonly-redefinition

```ts
readonly readonly-redefinition: object;
```

#### properties.overrides.items.properties.rules.properties.readonly-redefinition.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.sealed-reset-value

```ts
readonly sealed-reset-value: object;
```

#### properties.overrides.items.properties.rules.properties.sealed-reset-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.structure-ambiguous-record

```ts
readonly structure-ambiguous-record: object;
```

#### properties.overrides.items.properties.rules.properties.structure-ambiguous-record.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.structure-unknown-record

```ts
readonly structure-unknown-record: object;
```

#### properties.overrides.items.properties.rules.properties.structure-unknown-record.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.structure-unknown-selector

```ts
readonly structure-unknown-selector: object;
```

#### properties.overrides.items.properties.rules.properties.structure-unknown-selector.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.undocumented-css-part

```ts
readonly undocumented-css-part: object;
```

#### properties.overrides.items.properties.rules.properties.undocumented-css-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.undocumented-modifier

```ts
readonly undocumented-modifier: object;
```

#### properties.overrides.items.properties.rules.properties.undocumented-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.undocumented-part

```ts
readonly undocumented-part: object;
```

#### properties.overrides.items.properties.rules.properties.undocumented-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.unknown-annotation-ref

```ts
readonly unknown-annotation-ref: object;
```

#### properties.overrides.items.properties.rules.properties.unknown-annotation-ref.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.unknown-custom-property

```ts
readonly unknown-custom-property: object;
```

#### properties.overrides.items.properties.rules.properties.unknown-custom-property.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.unknown-modifier

```ts
readonly unknown-modifier: object;
```

#### properties.overrides.items.properties.rules.properties.unknown-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.unknown-part

```ts
readonly unknown-part: object;
```

#### properties.overrides.items.properties.rules.properties.unknown-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.properties.unknown-state

```ts
readonly unknown-state: object;
```

#### properties.overrides.items.properties.rules.properties.unknown-state.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.overrides.items.properties.rules.type

```ts
readonly type: "object" = "object";
```

#### properties.overrides.items.required

```ts
readonly required: readonly ["files", "rules"];
```

#### properties.overrides.items.type

```ts
readonly type: "object" = "object";
```

#### properties.overrides.type

```ts
readonly type: "array" = "array";
```

#### properties.providers

```ts
readonly providers: object;
```

#### properties.providers.description

```ts
readonly description: "Upstream cssdoc providers this config consumes, so their components resolve in this scope's lint/hover/docs. Each points at a provider's model.json or a source stylesheet." = "Upstream cssdoc providers this config consumes, so their components resolve in this scope's lint/hover/docs. Each points at a provider's model.json or a source stylesheet.";
```

#### properties.providers.items

```ts
readonly items: object;
```

#### properties.providers.items.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.providers.items.properties

```ts
readonly properties: object;
```

#### properties.providers.items.properties.baseHref

```ts
readonly baseHref: object;
```

#### properties.providers.items.properties.baseHref.description

```ts
readonly description: "URL prefix for links to the provider's rendered doc pages." = "URL prefix for links to the provider's rendered doc pages.";
```

#### properties.providers.items.properties.baseHref.type

```ts
readonly type: "string" = "string";
```

#### properties.providers.items.properties.path

```ts
readonly path: object;
```

#### properties.providers.items.properties.path.description

```ts
readonly description: "Path to the provider's model.json or a source stylesheet — relative (starts with .) or a package specifier." = "Path to the provider's model.json or a source stylesheet — relative (starts with .) or a package specifier.";
```

#### properties.providers.items.properties.path.type

```ts
readonly type: "string" = "string";
```

#### properties.providers.items.properties.prefix

```ts
readonly prefix: object;
```

#### properties.providers.items.properties.prefix.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.providers.items.properties.prefix.description

```ts
readonly description: "Rewrite the provider's base-class prefix before merging its records (e.g. a published `instui-` consumed under a different spelling). `to` is used verbatim — no separator is added or assumed." = "Rewrite the provider's base-class prefix before merging its records (e.g. a published `instui-` consumed under a different spelling). `to` is used verbatim — no separator is added or assumed.";
```

#### properties.providers.items.properties.prefix.properties

```ts
readonly properties: object;
```

#### properties.providers.items.properties.prefix.properties.from

```ts
readonly from: object;
```

#### properties.providers.items.properties.prefix.properties.from.description

```ts
readonly description: "The prefix as published, matched from the start of the class name — a literal string, or a regex source when isRegExp is true." = "The prefix as published, matched from the start of the class name — a literal string, or a regex source when isRegExp is true.";
```

#### properties.providers.items.properties.prefix.properties.from.type

```ts
readonly type: "string" = "string";
```

#### properties.providers.items.properties.prefix.properties.isRegExp

```ts
readonly isRegExp: object;
```

#### properties.providers.items.properties.prefix.properties.isRegExp.description

```ts
readonly description: "Treat `from` as a regex source instead of a literal string." = "Treat `from` as a regex source instead of a literal string.";
```

#### properties.providers.items.properties.prefix.properties.isRegExp.type

```ts
readonly type: "boolean" = "boolean";
```

#### properties.providers.items.properties.prefix.properties.to

```ts
readonly to: object;
```

#### properties.providers.items.properties.prefix.properties.to.description

```ts
readonly description: "The literal replacement text (verbatim, no separator assumed). Omit or use \"\" to strip the prefix to a bare class." = 'The literal replacement text (verbatim, no separator assumed). Omit or use "" to strip the prefix to a bare class.';
```

#### properties.providers.items.properties.prefix.properties.to.type

```ts
readonly type: "string" = "string";
```

#### properties.providers.items.properties.prefix.required

```ts
readonly required: readonly ["from"];
```

#### properties.providers.items.properties.prefix.type

```ts
readonly type: "object" = "object";
```

#### properties.providers.items.required

```ts
readonly required: readonly ["path"];
```

#### properties.providers.items.type

```ts
readonly type: "object" = "object";
```

#### properties.providers.type

```ts
readonly type: "array" = "array";
```

#### properties.render

```ts
readonly render: object;
```

#### properties.render.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.render.description

```ts
readonly description: "Markdown render options for the CSS API pages (used by @cssdoc/markdown and @cssdoc/typedoc). Explicit emitter options still override these." = "Markdown render options for the CSS API pages (used by @cssdoc/markdown and @cssdoc/typedoc). Explicit emitter options still override these.";
```

#### properties.render.properties

```ts
readonly properties: object;
```

#### properties.render.properties.baseHref

```ts
readonly baseHref: object;
```

#### properties.render.properties.baseHref.description

```ts
readonly description: "Base href for @related cross-links and the sidebar/index links." = "Base href for @related cross-links and the sidebar/index links.";
```

#### properties.render.properties.baseHref.type

```ts
readonly type: "string" = "string";
```

#### properties.render.properties.groups

```ts
readonly groups: object;
```

#### properties.render.properties.groups.description

```ts
readonly description: "Explicit sidebar/index group order. Listed group labels come first, in this order; unlisted groups follow the default order (record kinds, then custom @group groups)." = "Explicit sidebar/index group order. Listed group labels come first, in this order; unlisted groups follow the default order (record kinds, then custom @group groups).";
```

#### properties.render.properties.groups.items

```ts
readonly items: object;
```

#### properties.render.properties.groups.items.type

```ts
readonly type: "string" = "string";
```

#### properties.render.properties.groups.type

```ts
readonly type: "array" = "array";
```

#### properties.render.properties.headingPrefix

```ts
readonly headingPrefix: object;
```

#### properties.render.properties.headingPrefix.description

```ts
readonly description: "Prefix for each record page title, e.g. \"CSS:\"." = 'Prefix for each record page title, e.g. "CSS:".';
```

#### properties.render.properties.headingPrefix.type

```ts
readonly type: "string" = "string";
```

#### properties.render.properties.sectionOrder

```ts
readonly sectionOrder: object;
```

#### properties.render.properties.sectionOrder.description

```ts
readonly description: "Order (and inclusion) of the reorderable ## sections on a record page; omitted keys are dropped." = "Order (and inclusion) of the reorderable ## sections on a record page; omitted keys are dropped.";
```

#### properties.render.properties.sectionOrder.items

```ts
readonly items: object;
```

#### properties.render.properties.sectionOrder.items.enum

```ts
readonly enum: readonly ["demo", "examples", "usage", "annotations", "modifiers", "parts", "shadowParts", "pseudoElements", "states", "slots", "structure", "subcomponents", "cssProperties", "functions", "animations", "layers", "conditions", "tokensConsumed", "compat", "accessibility", "related", "see"];
```

#### properties.render.properties.sectionOrder.type

```ts
readonly type: "array" = "array";
```

#### properties.render.properties.structureVariantView

```ts
readonly structureVariantView: object;
```

#### properties.render.properties.structureVariantView.description

```ts
readonly description: "How alternative DOM shapes (from top-level @variant blocks in @structure) render: \"diagram\" (default) emits one combined flowchart with a labelled subgraph per variant; \"sections\" emits a \"### Variant: <name>\" subsection per variant." = 'How alternative DOM shapes (from top-level @variant blocks in @structure) render: "diagram" (default) emits one combined flowchart with a labelled subgraph per variant; "sections" emits a "### Variant: <name>" subsection per variant.';
```

#### properties.render.properties.structureVariantView.enum

```ts
readonly enum: readonly ["diagram", "sections"];
```

#### properties.render.properties.structureView

```ts
readonly structureView: object;
```

#### properties.render.properties.structureView.description

```ts
readonly description: "Which Structure representation(s) to emit: \"text\" tree, \"diagram\" flowchart, or \"both\" (default)." = 'Which Structure representation(s) to emit: "text" tree, "diagram" flowchart, or "both" (default).';
```

#### properties.render.properties.structureView.enum

```ts
readonly enum: readonly ["text", "diagram", "both"];
```

#### properties.render.type

```ts
readonly type: "object" = "object";
```

#### properties.ruleOptions

```ts
readonly ruleOptions: object;
```

#### properties.ruleOptions.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.ruleOptions.description

```ts
readonly description: "Policy options for rule behavior families." = "Policy options for rule behavior families.";
```

#### properties.ruleOptions.properties

```ts
readonly properties: object;
```

#### properties.ruleOptions.properties.sealed

```ts
readonly sealed: object;
```

#### properties.ruleOptions.properties.sealed.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.ruleOptions.properties.sealed.properties

```ts
readonly properties: object;
```

#### properties.ruleOptions.properties.sealed.properties.mode

```ts
readonly mode: object;
```

#### properties.ruleOptions.properties.sealed.properties.mode.description

```ts
readonly description: "strict flags full reset-keyword set; compat limits to unset/initial." = "strict flags full reset-keyword set; compat limits to unset/initial.";
```

#### properties.ruleOptions.properties.sealed.properties.mode.enum

```ts
readonly enum: readonly ["strict", "compat"];
```

#### properties.ruleOptions.properties.sealed.type

```ts
readonly type: "object" = "object";
```

#### properties.ruleOptions.properties.values

```ts
readonly values: object;
```

#### properties.ruleOptions.properties.values.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.ruleOptions.properties.values.properties

```ts
readonly properties: object;
```

#### properties.ruleOptions.properties.values.properties.allowInherit

```ts
readonly allowInherit: object;
```

#### properties.ruleOptions.properties.values.properties.allowInherit.description

```ts
readonly description: "Allow `inherit` in sealed/frozen value checks (default false)." = "Allow `inherit` in sealed/frozen value checks (default false).";
```

#### properties.ruleOptions.properties.values.properties.allowInherit.type

```ts
readonly type: "boolean" = "boolean";
```

#### properties.ruleOptions.properties.values.type

```ts
readonly type: "object" = "object";
```

#### properties.ruleOptions.type

```ts
readonly type: "object" = "object";
```

#### properties.rules

```ts
readonly rules: object;
```

#### properties.rules.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.rules.description

```ts
readonly description: "Per-rule severity overrides (off/warn/error)." = "Per-rule severity overrides (off/warn/error).";
```

#### properties.rules.properties

```ts
readonly properties: object;
```

#### properties.rules.properties.alias-requires-canonical

```ts
readonly alias-requires-canonical: object;
```

#### properties.rules.properties.alias-requires-canonical.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.component-name-case

```ts
readonly component-name-case: object;
```

#### properties.rules.properties.component-name-case.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.conflicting-global-modifier

```ts
readonly conflicting-global-modifier: object;
```

#### properties.rules.properties.conflicting-global-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.cssdoc-directive

```ts
readonly cssdoc-directive: object;
```

#### properties.rules.properties.cssdoc-directive.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.deprecated-modifier

```ts
readonly deprecated-modifier: object;
```

#### properties.rules.properties.deprecated-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.deprecated-requires-canonical

```ts
readonly deprecated-requires-canonical: object;
```

#### properties.rules.properties.deprecated-requires-canonical.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.disallowed-element

```ts
readonly disallowed-element: object;
```

#### properties.rules.properties.disallowed-element.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.duplicate-record-id

```ts
readonly duplicate-record-id: object;
```

#### properties.rules.properties.duplicate-record-id.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.duplicate-record-id-cross-kind

```ts
readonly duplicate-record-id-cross-kind: object;
```

#### properties.rules.properties.duplicate-record-id-cross-kind.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.invalid-default-value

```ts
readonly invalid-default-value: object;
```

#### properties.rules.properties.invalid-default-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.invalid-fallback-value

```ts
readonly invalid-fallback-value: object;
```

#### properties.rules.properties.invalid-fallback-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.invalid-property-value

```ts
readonly invalid-property-value: object;
```

#### properties.rules.properties.invalid-property-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.missing-summary

```ts
readonly missing-summary: object;
```

#### properties.rules.properties.missing-summary.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.name-not-in-css

```ts
readonly name-not-in-css: object;
```

#### properties.rules.properties.name-not-in-css.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.part-name-case

```ts
readonly part-name-case: object;
```

#### properties.rules.properties.part-name-case.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.readonly-redefinition

```ts
readonly readonly-redefinition: object;
```

#### properties.rules.properties.readonly-redefinition.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.sealed-reset-value

```ts
readonly sealed-reset-value: object;
```

#### properties.rules.properties.sealed-reset-value.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.structure-ambiguous-record

```ts
readonly structure-ambiguous-record: object;
```

#### properties.rules.properties.structure-ambiguous-record.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.structure-unknown-record

```ts
readonly structure-unknown-record: object;
```

#### properties.rules.properties.structure-unknown-record.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.structure-unknown-selector

```ts
readonly structure-unknown-selector: object;
```

#### properties.rules.properties.structure-unknown-selector.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.undocumented-css-part

```ts
readonly undocumented-css-part: object;
```

#### properties.rules.properties.undocumented-css-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.undocumented-modifier

```ts
readonly undocumented-modifier: object;
```

#### properties.rules.properties.undocumented-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.undocumented-part

```ts
readonly undocumented-part: object;
```

#### properties.rules.properties.undocumented-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.unknown-annotation-ref

```ts
readonly unknown-annotation-ref: object;
```

#### properties.rules.properties.unknown-annotation-ref.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.unknown-custom-property

```ts
readonly unknown-custom-property: object;
```

#### properties.rules.properties.unknown-custom-property.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.unknown-modifier

```ts
readonly unknown-modifier: object;
```

#### properties.rules.properties.unknown-modifier.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.unknown-part

```ts
readonly unknown-part: object;
```

#### properties.rules.properties.unknown-part.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.properties.unknown-state

```ts
readonly unknown-state: object;
```

#### properties.rules.properties.unknown-state.enum

```ts
readonly enum: readonly ["off", "warn", "error"];
```

#### properties.rules.type

```ts
readonly type: "object" = "object";
```

#### properties.structureIgnore

```ts
readonly structureIgnore: object;
```

#### properties.structureIgnore.description

```ts
readonly description: "Class names to exempt from the structure-unknown-selector rule — legitimately-external classes (utilities, cross-component refs) referenced in @structure. Literal names or simple globs where * matches any run of characters (e.g. util-*)." = "Class names to exempt from the structure-unknown-selector rule — legitimately-external classes (utilities, cross-component refs) referenced in @structure. Literal names or simple globs where * matches any run of characters (e.g. util-*).";
```

#### properties.structureIgnore.items

```ts
readonly items: object;
```

#### properties.structureIgnore.items.type

```ts
readonly type: "string" = "string";
```

#### properties.structureIgnore.type

```ts
readonly type: "array" = "array";
```

#### properties.supportForTags

```ts
readonly supportForTags: object;
```

#### properties.supportForTags.additionalProperties

```ts
readonly additionalProperties: object;
```

#### properties.supportForTags.additionalProperties.type

```ts
readonly type: "boolean" = "boolean";
```

#### properties.supportForTags.description

```ts
readonly description: "Enable or disable specific tags by name." = "Enable or disable specific tags by name.";
```

#### properties.supportForTags.type

```ts
readonly type: "object" = "object";
```

#### properties.tagDefinitions

```ts
readonly tagDefinitions: object;
```

#### properties.tagDefinitions.description

```ts
readonly description: "Custom tags to register." = "Custom tags to register.";
```

#### properties.tagDefinitions.items

```ts
readonly items: object;
```

#### properties.tagDefinitions.items.additionalProperties

```ts
readonly additionalProperties: false = false;
```

#### properties.tagDefinitions.items.properties

```ts
readonly properties: object;
```

#### properties.tagDefinitions.items.properties.aliasFor

```ts
readonly aliasFor: object;
```

#### properties.tagDefinitions.items.properties.aliasFor.type

```ts
readonly type: "string" = "string";
```

#### properties.tagDefinitions.items.properties.allowMultiple

```ts
readonly allowMultiple: object;
```

#### properties.tagDefinitions.items.properties.allowMultiple.type

```ts
readonly type: "boolean" = "boolean";
```

#### properties.tagDefinitions.items.properties.recordKind

```ts
readonly recordKind: object;
```

#### properties.tagDefinitions.items.properties.recordKind.enum

```ts
readonly enum: readonly ["component", "utility", "rule", "declaration", "layout"];
```

#### properties.tagDefinitions.items.properties.syntaxKind

```ts
readonly syntaxKind: object;
```

#### properties.tagDefinitions.items.properties.syntaxKind.enum

```ts
readonly enum: readonly ["record", "block", "modifier", "inline"];
```

#### properties.tagDefinitions.items.properties.tagName

```ts
readonly tagName: object;
```

#### properties.tagDefinitions.items.properties.tagName.pattern

```ts
readonly pattern: "^@?[a-zA-Z][a-zA-Z0-9-]*$" = "^@?[a-zA-Z][a-zA-Z0-9-]*$";
```

#### properties.tagDefinitions.items.properties.tagName.type

```ts
readonly type: "string" = "string";
```

#### properties.tagDefinitions.items.required

```ts
readonly required: readonly ["tagName", "syntaxKind"];
```

#### properties.tagDefinitions.items.type

```ts
readonly type: "object" = "object";
```

#### properties.tagDefinitions.type

```ts
readonly type: "array" = "array";
```

### title

```ts
readonly title: "cssdoc.json" = "cssdoc.json";
```

### type

```ts
readonly type: "object" = "object";
```