cssdoc

Appearance

Variable: cssDocSchema ​

ts
const cssDocSchema: object;

Defined in: packages/config/src/schema.ts:10

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.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.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";

Released under the MIT License

Copyright © 2026-present iyWahl