import { Severity, Plugin, Rule, Formatter, FormatterType, ConfigRuleSettings, DisableOptions, CustomSyntax as CustomSyntax$1 } from 'stylelint';
export { Severity } from 'stylelint';
import * as CSS from 'csstype';

interface SecondaryOptions {
  /**
   * You can set the `disableFix` secondary option to disable autofix on a per-rule basis.
   * @see [configure disable fix](https://stylelint.io/user-guide/configure#disablefix)
   */
  disableFix?: boolean
  /**
   * You can set the reportDisables secondary option to report any stylelint-disable comments
   * for this rule, effectively disallowing authors to opt-out of it.
   * @see [configure report disables](https://stylelint.io/user-guide/configure#reportdisables)
   */
  reportDisables?: boolean
  /**
   * You can use the severity secondary option to adjust any specific rule's severity.
   *
   * The available values for severity are:
   * - "warning"
   * - "error" (default)
   * @see [configure severity](https://stylelint.io/user-guide/configure#severity)
   */
  severity?: Severity
  /**
   * You can use the message secondary option to deliver a custom message when a rule is violated.
   * @see [configure message](https://stylelint.io/user-guide/configure#message)
   */
  message?: string | ((...args: any[]) => string)

  /**
   * You can use the url secondary option to provide a custom link to external docs.
   * These urls can then be displayed in custom formatters.
   * @see [configure url](https://stylelint.io/user-guide/configure#url)
   */
  url?: string
}

/**
 * declaration rule config.
 *
 * `RuleConfig<PrimaryOptions, SecondaryOptions>`
 */
type RuleConfig<T, S extends Record<string, any> = Record<string, any>>
  = null
    | undefined
    | NonNullable<T>
    | readonly [NonNullable<T>]
    | readonly [NonNullable<T>, Omit<SecondaryOptions, keyof S> & S]

type Unprefix<T extends Record<string, any>, Pre extends string> = {
    [K in keyof T as K extends `${Pre}${infer U}` ? U : never]: T[K];
};
type Prefix<T extends Record<string, any>, Pre extends string> = {
    [K in keyof T as `${Pre}${K}`]: T[K];
};
type RenamePrefix<T extends Record<string, any>, Old extends string, New extends string> = Prefix<Unprefix<T, Old>, New>;
/**
 * A literal type that supports custom further strings but preserves autocompletion in IDEs.
 *
 * @see [copied from issue](https://github.com/microsoft/TypeScript/issues/29729#issuecomment-471566609)
 */
type LiteralUnion<Union extends Base, Base = string> = Union | (Base & {
    zz_IGNORE_ME?: never;
});
type RegExpLike = RegExp | `/${string}/` | string;
type KebabCase<S extends string, B extends boolean = true> = S extends `${infer F}${infer O}` ? F extends Uncapitalize<F> ? `${F}${KebabCase<O, false>}` : B extends true ? `${Uncapitalize<F>}${KebabCase<O, false>}` : `-${Uncapitalize<F>}${KebabCase<O, false>}` : S;

type AtRules = LiteralUnion<CSS.AtRules extends `@${infer T}` ? T : never>

type CSSFunction = LiteralUnion<
  | 'abs' | 'acos' | 'asin' | 'atan' | 'atan2' | 'attr' | 'calc' | 'clamp'
  | 'cos' | 'counter' | 'counters' | 'cross-fade' | 'env' | 'exp' | 'fix-content'
  | 'hypot' | 'log' | 'max' | 'min' | 'minmax' | 'pow' | 'rem' | 'repeat'
  | 'round' | 'sign' | 'sin' | 'sqrt' | 'symbols' | 'tan' | 'url' | 'var'
>

type MediaFeature = MediaFeatureNormal | MediaFeaturePrefix

type MediaFeatureNormal = LiteralUnion<
  // level 3
  | 'width' | 'height' | 'device-width' | 'device-height' | 'orientation'
  | 'aspect-ratio' | 'device-aspect-ratio' | 'color' | 'color-index'
  | 'monochrome' | 'resolution' | 'scan' | 'grid'
  // level 4
  | 'update' | 'overflow-block' | 'overflow-inline' | 'color-gamut'
  | 'pointer' | 'hover' | 'any-pointer' | 'any-hover'
>

type MediaFeaturePrefix = LiteralUnion<
  | 'max-width' | 'max-height' | 'max-device-width'
  | 'max-device-height' | 'max-aspect-ratio' | 'max-device-aspect-ratio'
  | 'max-color-index' | 'max-monochrome' | 'max-resolution' | 'max-color'
  | 'min-width' | 'min-height' | 'min-device-width' | 'min-device-height'
  | 'min-aspect-ratio' | 'min-device-aspect-ratio' | 'min-color'
  | 'min-color-index' | 'min-monochrome' | 'min-resolution'
>

type MediaFeatureLevel5 = LiteralUnion<
  | 'horizontal-viewport-segments' | 'vertical-viewport-segments'
  | 'display-mode' | 'environment-blending' | 'dynamic-range'
  | 'inverted-colors' | 'nav-controls'
  | 'video-color-gamut' | 'video-dynamic-range' | 'scripting'
  | 'prefers-reduced-motion' | 'prefers-reduced-transparency'
  | 'prefers-contrast' | 'forced-colors' | 'prefers-color-scheme'
  | 'prefers-reduced-data'
>

type MediaType = LiteralUnion<'all' | 'screen' | 'print'>

type CSSPropertiesMap = keyof CSS.Properties

type StandardPropertiesMap = keyof CSS.StandardProperties

type KebabCaseStandardPropertiesMap = LiteralUnion<KebabCase<StandardPropertiesMap>>

type SelectorAttributeOperator = LiteralUnion<'=' | '~=' | '|=' | '^=' | '$=' | '*='>

type SelectorCombinator = LiteralUnion<' ' | '>' | '+' | '~' | '||' | '|' | ','>

type SelectorPseudoClass = LiteralUnion<
  | 'active' | 'any-link' | 'autofill' | 'buffering' | 'blank' | 'checked'
  | 'current' | 'default' | 'defined' | 'dir' | 'disabled' | 'empty'
  | 'enabled' | 'first' | 'first-child' | 'first-of-type' | 'focus' | 'focus-visible'
  | 'focus-within' | 'fullscreen' | 'hover' | 'future' | 'has' | 'host' | 'host-context'
  | 'hover' | 'indeterminate' | 'in-range' | 'invalid' | 'is' | 'lang'
  | 'last-child' | 'last-of-type' | 'left' | 'link' | 'local-link' | 'modal' | 'muted' | 'not'
  | 'nth-child' | 'nth-last-child' | 'nth-last-of-type' | 'not-of-type' | 'only-child'
  | 'only-of-type' | 'optional' | 'out-of-range' | 'past' | 'paused' | 'picture-in-picture'
  | 'placeholder-shown' | 'playing' | 'popover-open' | 'ready-only' | 'read-write'
  | 'required' | 'right' | 'root' | 'scope' | 'seeking' | 'stalled' | 'target' | 'target-within'
  | 'user-invalid' | 'user-valid' | 'valid' | 'visited' | 'volume-locked' | 'where'
>

type SelectorPseudoElement = LiteralUnion<
  | 'before' | 'after' | 'backdrop' | 'cue' | 'cue-region' | 'file-selector-button'
  | 'first-letter' | 'first-line' | 'highlight' | 'marker' | 'part' | 'placeholder'
  | 'selection' | 'slotted'
>

type RelativeUnit = 'em' | 'rem' | 'vw' | 'vh' | 'vmin' | 'vmax' | 'ex' | 'cap' | 'ch' | 'ic' | 'lh' | 'rlh' | 'vi' | 'vb' | 'svw' | 'svh' | 'lvw' | 'lvh' | 'dvw' | 'dvh'

type AbsoluteUnit = 'px' | 'pt' | 'cm' | 'mm' | 'Q' | 'in' | 'pc'

type AngleUnit = 'deg' | 'grad' | 'rad' | 'turn'

type PercentUnit = '%'

type TimeUnit = 'ms' | 's'

type FrequencyUnit = 'Hz' | 'kHz'

type ResolutionUnit = 'dpi' | 'dpcm' | 'dppx'

type CustomUnit = 'rpx'

type Unit = LiteralUnion<RelativeUnit | AbsoluteUnit | AngleUnit | PercentUnit | TimeUnit | FrequencyUnit | ResolutionUnit | CustomUnit>

type AlphaValueNotationPrimaryOptions = 'number' | 'percentage'

interface AlphaValueNotationSecondaryOptions {
  /**
   * Reverse the primary option for matching properties.
   * @see [optional secondary options](https://stylelint.io/user-guide/rules/alpha-value-notation#optional-secondary-options)
   */
  exceptProperties?: (CSSPropertiesMap | RegExpLike)[]

  message?: string | ((unfixed: string, fixed: string) => string)
}

type AlphaValueNotationOptions = RuleConfig<
  AlphaValueNotationPrimaryOptions,
  AlphaValueNotationSecondaryOptions
>

type AnnotationNoUnknownOptions = RuleConfig<
  true,
  {
    /**
     * Specify which annotations to ignore.
     */
    ignoreAnnotations?: RegExpLike[]

    message?: string | ((annotation: string) => string)
  }
>

type AtRuleAllowedListOptions = RuleConfig<
  AtRules[] | string[],
  {
    message?: string | ((atRule: string) => string)
  }
>

type AtRuleDescriptorNoUnknownOptions = RuleConfig<true, {
  message?: string | ((atRule: string, descriptor: string) => string)
}>

type AtRuleDescriptorValueNoUnknownOptions = RuleConfig<true, {
  message?: string | ((descriptor: string, value: string) => string)
}>

type AtRuleDisallowedListOptions = RuleConfig<
  AtRules[] | string[],
  {
    message?: string | ((atRule: string) => string)
  }
>

type AtRuleEmptyLineBeforeOptions = RuleConfig<
  'always' | 'never',
  {
    except?: LiteralUnion<'after-same-name' | 'inside-block' | 'blockless-after-same-name-blockless' | 'blockless-after-blockless' | 'first-nested'>[]
    ignore?: LiteralUnion<'after-comment' | 'first-nested' | 'inside-block' | 'blockless-after-same-name-blockless' | 'blockless-after-blockless'>[]
    ignoreAtRules?: (AtRules | RegExp | `/${string}/`)[]
    message?: string | ((atRule: string) => string)
  }
>

type AtRuleNoDeprecatedOptions = RuleConfig<true, {
  ignoreAtRules?: (RegExp | AtRules)[]
  message?: string | ((atRule: string) => string)
}>

type AtRuleNoUnknownOptions = RuleConfig<
  true,
  {
    ignoreAtRules?: (string | RegExp)[]
    message?: string | ((atRule: string) => string)
  }
>

type AtRuleNoVendorPrefixOptions = RuleConfig<
  true,
  {
    message: string | ((atRule: string) => string)
  }
>

type AtRulePreludeNoInvalidOptions = RuleConfig<true, {
  ignoreAtRules?: (RegExp | AtRules)[]
  message?: string | ((atRule: string, prelude: string) => string)
}>

type AtRulePropertyRequiredListOptions = RuleConfig<
  Record<AtRules, CSSPropertiesMap | CSSPropertiesMap[]>,
  {
    message?: string | ((atRule: string, property: string) => string)
  }
>

type BlockNoEmptyOptions = RuleConfig<
  true,
  {
    ignore?: ('comments')[]
    message?: string | ((block: string) => string)
  }
>

type ColorFunctionAliasNatationOptions = RuleConfig<
  'without-alpha' | 'with-alpha',
  {
    message?: string | ((unfixed: string, fixed: string) => string)
  }
>

type ColorFunctionNatationOptions = RuleConfig<
  'modern' | 'legacy',
  {
    ignore?: ('with-var-inside')[]
    message?: string | ((primary: string) => string)
  }
>

type ColorHexAlphaOptions = RuleConfig<
  'always' | 'never',
  {
    message?: string | ((hex: string) => string)
  }
>

type ColorHexLengthOptions = RuleConfig<
  'short' | 'long',
  {
    message?: string | ((actual: string, expected: string) => string)
  }
>

type ColorNamedOptions = RuleConfig<
  'always-where-possible' | 'never',
  {
    ignoreProperties?: RegExpLike[]
    ignore?: ('inside-function')[]
    message?: string | ((named: string) => string)
  }
>

type ColorNoHexOptions = RuleConfig<
  true,
  {
    message?: string | ((hex: string, expected: string) => string)
  }
>

type ColorNoInvalidHexOptions = RuleConfig<
  true,
  {
    message?: string | ((hex: string, expected: string) => string)
  }
>

type CommentEmptyLineBeforeOptions = RuleConfig<
  'always' | 'never',
  {
    except?: ('first-nested')[]
    ignore?: ('stylelint-commands' | 'after-comment')[]
    ignoreComments?: RegExpLike[]
  }
>

type CommentNoEmptyOptions = RuleConfig<
  true
>

type CommentPatternOptions = RuleConfig<
  RegExpLike
>

type CommentWhitespaceInsideOptions = RuleConfig<
  'always' | 'never'
>

type CommentWordDisallowedListOptions = RuleConfig<
  RegExpLike | RegExpLike[],
  {
    message?: string | ((pattern: string) => string)
  }
>

type ContainerNamePatternOptions = RuleConfig<
  RegExpLike,
  {
    message?: string | ((containerName: string, pattern: string) => string)
  }
>

type CustomMediaPatternOptions = RuleConfig<
  RegExpLike,
  {
    message?: string | ((mediaName: string, pattern: string) => string)
  }
>

type CustomPropertyEmptyLineBeforeOptions = RuleConfig<
  'always' | 'never',
  {
    except?: LiteralUnion<'after-comment' | 'after-custom-property' | 'first-nested'>[]
    ignore?: LiteralUnion<'after-comment' | 'first-nested' | 'inside-single-line-block'>[]
    message?: string | (() => string)
  }
>

type CustomPropertyNoMissingVarFunctionOptions = RuleConfig<
  true,
  {
    message?: string | ((customProperty: string) => string)
  }
>

type CustomPropertyPatternOptions = RuleConfig<
  RegExpLike,
  {
    message?: string | ((propName: string, pattern: string) => string)
  }
>

type DeclarationBlockNoDuplicateCustomPropertiesOptions = RuleConfig<
  true,
  {
    ignoreProperties?: (string | RegExp)[]
    message?: string | ((property: string) => string)
  }
>

type DeclarationBlockNoDuplicatePropertiesIgnore = LiteralUnion<
  | 'consecutive-duplicates'
  | 'consecutive-duplicates-with-different-values'
  | 'consecutive-duplicates-with-different-syntaxes'
  | 'consecutive-duplicates-with-same-prefixless-values'
>

type DeclarationBlockNoDuplicatePropertiesOptions = RuleConfig<
  true,
  {
    ignore?: [DeclarationBlockNoDuplicatePropertiesIgnore]
    ignoreProperties?: (string | RegExp)[]
    message?: string | ((property: string) => string)
  }
>

type DeclarationBlockNoRedundantLonghandPropertiesOptions = RuleConfig<
  true,
  {
    ignoreLonghands?: string | string[]
    ignoreShorthands?: (string | RegExp)[]
    message?: string | ((props: string) => string)
  }
>

type DeclarationBlockNoShorthandPropertyOverridesOptions = RuleConfig<
  true,
  {
    message?: string | ((shorthand: string, original: string) => string)
  }
>

type DeclarationBlockSingleLineMaxDeclarationsOptions = RuleConfig<
  number,
  {
    message?: string | ((max: number) => string)
  }
>

type DeclarationEmptyLineBeforeOptions = RuleConfig<
  'always' | 'never',
  {
    except?: LiteralUnion<'after-comment' | 'after-declaration' | 'first-nested'>[]
    ignore?: LiteralUnion<'after-comment' | 'after-declaration' | 'first-nested' | 'inside-single-line-block'>[]
    ignoreProperties?: RegExpLike[]
  }
>

type DeclarationNoImportantOptions = RuleConfig<
  true
>

type DeclarationPropertyMaxValuesOptions = RuleConfig<
  Record<KebabCaseStandardPropertiesMap | `/${string}/`, number> | Record<string, number>,
  {
    message?: string | ((property: string, max: number) => string)
  }
>

type DeclarationPropertyUnitAllowedListOptions = RuleConfig<
  Record<KebabCaseStandardPropertiesMap | `/${string}/`, Unit | Unit[]>,
  {
    ignore?: ['inside-function']
    message?: string | ((property: string, unit: string) => string)
  }
>

type DeclarationPropertyUnitDisallowedListOptions = RuleConfig<
  Record<KebabCaseStandardPropertiesMap | `/${string}/`, Unit | Unit[]>,
  {
    message?: string | ((property: string, unit: string) => string)
  }
>

type DeclarationPropertyValueAllowedListOptions = RuleConfig<
  Record<KebabCaseStandardPropertiesMap | `/${string}/`, RegExpLike | RegExpLike[]>
  | Record<string, RegExpLike | RegExpLike[]>,
  {
    message?: string | ((property: string, value: string) => string)
  }
>

type DeclarationPropertyValueDisallowedListOptions = RuleConfig<
  Record<KebabCaseStandardPropertiesMap | `/${string}/`, RegExpLike | RegExpLike[]>
  | Record<string, RegExpLike | RegExpLike[]>,
  {
    message?: string | ((property: string, value: string) => string)
  }
>

type DeclarationPropertyValueKeywordNoDeprecatedOptions = RuleConfig<true, {
  ignoreKeywords?: (RegExp | string)[]
  message?: string | ((property: string, keyword: string) => string)
}>

type DeclarationPropertyValueNoUnknownOptions = RuleConfig<true, {
  ignoreProperties?: Record<KebabCaseStandardPropertiesMap, RegExpLike | RegExpLike[]> | Record<string, RegExpLike | RegExpLike[]>
  /**
   * Extend or alter the properties syntax dictionary.
   * {@link https://github.com/csstree/csstree/blob/master/docs/definition-syntax.md CSS Value Definition Syntax} is used to define a value's syntax.
   * If a definition starts with `|` it is added to the {@link https://csstree.github.io/docs/syntax/ existing definition value} if any.
   */
  propertiesSyntax?: Record<KebabCaseStandardPropertiesMap, string> | Record<string, string>
  /**
   * Extend or alter the types syntax dictionary.
   * {@link https://github.com/csstree/csstree/blob/master/docs/definition-syntax.md CSS Value Definition Syntax} is used to define a value's syntax.
   * If a definition starts with `|` it is added to the {@link https://csstree.github.io/docs/syntax/ existing definition value} if any.
   */
  typesSyntax?: Record<string, string>

  message?: string | ((property: string, value: string) => string)
}>

type FontFamilyNameQuotesOptions = RuleConfig<
  'always-where-required' | 'always-where-recommended' | 'always-unless-keyword',
  {
    message?: string | ((familyName: string) => string)
  }
>

type FontFamilyNoDuplicateNamesOptions = RuleConfig<
  true,
  {
    ignoreFontFamilyNames?: (string | RegExp)[]
    message?: string | ((name: string) => string)
  }
>

type FontFamilyNoMissingGenericFamilyKeywordOptions = RuleConfig<
  true,
  {
    ignoreFontFamilies?: (string | RegExp)[]
    message?: string | (() => string)
  }
>

type FontWeightNotationIgnore = 'relative'

type FontWeightNotationOptions = RuleConfig<
  'numeric' | 'named-where-possible',
  {
    ignore?: [FontWeightNotationIgnore]
    message?: string | ((type: string) => string)
  }
>

type FunctionAllowedListOptions = RuleConfig<
  CSSFunction | RegExpLike | (CSSFunction | RegExpLike)[],
  {
    message?: string | ((name: string) => string)
    /**
     * Disallow the matching functions when they are without a property fallback in the same declaration block.
     */
    exceptWithoutPropertyFallback?: CSSFunction | RegExpLike | (CSSFunction | RegExpLike)[]
  }
>

type FunctionCalcNoUnspacedOperatorOptions = RuleConfig<
  true,
  {
    message?: string | ((operator: string) => string)
  }
>

type FunctionDisallowedListOptions = RuleConfig<
  CSSFunction | RegExpLike | (CSSFunction | RegExpLike)[],
  {
    message?: string | ((name: string) => string)
  }
>

type FunctionLinearGradientNoNonstandardDirectionOptions = RuleConfig<
  true
>

type FunctionNameCaseOptions = RuleConfig<
  'lower' | 'upper',
  {
    ignoreFunctions?: (string | RegExp)[]
    message?: string | ((actual: string, expected: string) => string)
  }
>

type FunctionNoUnknownOptions = RuleConfig<
  true,
  {
    ignoreFunctions?: (string | RegExp)[]
    message?: string | ((name: string) => string)
  }
>

type FunctionUrlNoSchemeRelativeOptions = RuleConfig<
  true,
  {
    ignoreFunctions?: RegExpLike[]
  }
>

type FunctionUrlQuotesExcept = 'empty'

type FunctionUrlQuotesOptions = RuleConfig<
  'always' | 'never',
  {
    except?: [FunctionUrlQuotesExcept]
    message?: string | ((functionName: string) => string)
  }
>

type FunctionUrlSchemeAllowedListOptions = RuleConfig<
  RegExp | string | (RegExp | string)[],
  {
    message?: string | ((scheme: string) => string)
  }
>

type FunctionUrlSchemeDisallowedListOptions = RuleConfig<
  string | RegExp | (string | RegExp)[],
  {
    message?: string | ((scheme: string) => string)
  }
>

type HueDegreeNotationOptions = RuleConfig<
  'angle' | 'number',
  {
    message?: string | ((unfixed: string, fixed: string) => string)
  }
>

type ImportNotationOptions = RuleConfig<
  'string' | 'url',
  {
    message?: string | ((unfixed: string, fixed: string) => string)
  }
>

type KeyframeBlockNoDuplicateSelectorsOptions = RuleConfig<
  true,
  {
    message?: string | ((selector: string) => string)
  }
>

type KeyframeDeclarationNoImportantOptions = RuleConfig<
  true
>

type KeyframeSelectorNotationOptions = RuleConfig<
  'keyword' | 'percentage' | 'percentage-unless-within-keyword-only-block',
  {
    message?: string | ((selector: string, fixedSelector: string) => string)
  }
>

type KeyframesNamePatternOptions = RuleConfig<
  string | RegExp,
  {
    message?: string | ((keyframeName: string, pattern: string) => string)
  }
>

type LayerNamePatternOptions = RuleConfig<string | RegExp>

type LengthZeroNoUnitOptions = RuleConfig<
  true,
  {
    /**
     * Ignore units for zero length in custom properties.
     */
    ignore?: ('custom-properties')[]

    ignoreFunctions?: (CSSFunction | RegExpLike)[]
    /**
     * Ignore units for zero lengths within the preludes of the specified at-rules.
     */
    ignorePreludeOfAtRules?: RegExpLike[]
    message?: string | (() => string)
  }
>

type LightnessNotationOptions = RuleConfig<'percentage' | 'number', {
    message?: string | ((unfixed: string, fixed: string) => string);
}>;

type MaxNestingDepthOptions = RuleConfig<
  number,
  {
    ignore?: ('blockless-at-rules' | 'pseudo-classes')[]
    ignoreAtRules?: (AtRules | RegExp)[]
    message?: string | ((depth: string) => string)
  }
>

type MediaFeatureNameAllowed = MediaFeatureNormal | MediaFeatureLevel5 | RegExpLike

type MediaFeatureNameAllowedListOptions = RuleConfig<
  MediaFeatureNameAllowed | (MediaFeatureNameAllowed)[],
  {
    message?: string | ((name: string) => string)
  }
>

type MediaFeatureNameDisallowed = MediaFeatureNormal | MediaFeatureLevel5 | RegExpLike

type MediaFeatureNameDisallowedListOptions = RuleConfig<
  MediaFeatureNameDisallowed | (MediaFeatureNameDisallowed)[],
  {
    message?: string | ((name: string) => string)
  }
>

type MediaFeatureNameNoUnknownOptions = RuleConfig<
  true,
  {
    ignoreMediaFeatureNames?: (string | RegExp)[]
    message?: string | ((mediaFeatureName: string) => string)
  }
>

type MediaFeatureNameNoVendorPrefixOptions = RuleConfig<
  true
>

type MediaFeatureNameUnitAllowedListOptions = RuleConfig<
  Partial<Record<MediaFeatureNormal | MediaFeatureLevel5 | `/${string}/`, Unit | Unit[]>>,
  {
    message?: string | ((unit: string, name: string) => string)
  }
>

type MediaFeatureNameValueAllowedListOptions = RuleConfig<
  Partial<Record<
    MediaFeatureNormal | MediaFeatureLevel5 | `/${string}/`,
    string | RegExp | (string | RegExp)[]
  >>,
  {
    message?: string | ((name: string, value: string) => string)
  }
>

type MediaFeatureNameValueNoUnknownOptions = RuleConfig<
  true,
  {
    message?: string | ((name: string, value: string) => string)
  }
>

type MediaFeatureRangeNotationOptions = RuleConfig<
  'context' | 'prefix',
  {
    message?: string | ((primary: string) => string)
  }
>

type MediaQueryNoInvalidOptions = RuleConfig<
  true,
  {
    message?: string | ((query: string, reason: string) => string)
    ignoreFunctions?: string | RegExp | (string | RegExp)[]
  }
>

type NamedGridAreasNoInvalidOptions = RuleConfig<
  true,
  {
    message?: string | ((name: string) => string)
  }
>

type NoDescendingSpecificityIgnore = 'selectors-within-list'
type NoDescendingSpecificityOptions = RuleConfig<
  true,
  {
    ignore?: [NoDescendingSpecificityIgnore]
    message?: string | ((selectorA: string, selectorB: string) => string)
  }
>

type NoDuplicateAtImportRulesOptions = RuleConfig<
  true,
  {
    message?: string | ((atImport: string) => string)
  }
>

type NoDuplicateSelectorsOptions = RuleConfig<
  true,
  {
    /**
     * This option will also disallow duplicate selectors within selector lists.
     * @default false
     */
    disallowInList?: boolean
    message?: string | ((selector: string, firstDuplicateLine: number | string) => string)
  }
>

type NoEmptySourceOptions = RuleConfig<
  true
>

type NoInvalidDoubleSlashCommentsOptions = RuleConfig<
  true
>

type NoInvalidPositionAtImportRuleOptions = RuleConfig<
  true,
  {
    ignoreAtRules?: (AtRules | RegExp)[]
    message?: string | (() => string)
  }
>

type NoIrregularWhitespaceOptions = RuleConfig<
  true
>

type NoUnknownAnimationsOptions = RuleConfig<
  true
>

type NoUnknownCustomMediaOptions = RuleConfig<
  true
>

type NoUnknownCustomPropertiesOptions = RuleConfig<
  true
>

type NumberMaxPrecisionOptions = RuleConfig<
  number,
  {
    /**
     * Ignore the precision of numbers for values with the specified units.
     */
    ignoreUnits?: (Unit | RegExp)[]
    /**
     * Change a primary option value for specified functions.
     */
    insideFunctions?: Record<string, number>

    message?: string | ((actual: string, expected: string) => string)
  }
>

type PropertyAllowed = CSSPropertiesMap | RegExpLike

type PropertyAllowedListOptions = RuleConfig<
  PropertyAllowed | PropertyAllowed[],
  {
    message?: string | ((property: string) => string)
  }
>

type PropertyDisallowed = CSSPropertiesMap | RegExpLike

type PropertyDisallowedListOptions = RuleConfig<
  PropertyDisallowed | PropertyDisallowed[],
  {
    message?: string | ((property: string) => string)
  }
>

type PropertyNoUnknownOptions = RuleConfig<
  true,
  {
    ignoreProperties?: (string | RegExp)[]
    /**
     * Skips checking properties of the given selectors against this rule.
     */
    ignoreSelectors?: (string | RegExp)[]
    /**
     * Ignores properties nested within specified at-rules.
     */
    ignoreAtRules?: (AtRules | RegExp)[]
    /**
     * If true, this rule will check vendor-prefixed properties.
     * @default false
     */
    checkPrefixed?: boolean

    message?: string | ((property: string) => string)
  }
>

type PropertyNoVendorPrefixOptions = RuleConfig<
  true,
  {
    ignoreProperties?: (CSSPropertiesMap | RegExp)[] | (string | RegExp)[]
    message?: string | ((property: string) => string)
  }
>

type RuleEmptyLineBeforeOptions = RuleConfig<
  'always' | 'never' | 'always-multi-line' | 'never-multi-line',
  {
    except?: LiteralUnion<'after-rule' | 'after-single-line-comment' | 'inside-block-and-after-rule' | 'inside-block' | 'first-nested'>[]
    ignore?: LiteralUnion<'after-comment' | 'first-nested' | 'inside-block'>[]
    message?: string | ((property: string) => string)
  }
>

type RuleSelectorPropertyDisallowed = CSSPropertiesMap | RegExpLike

type RuleSelectorPropertyDisallowedListOptions = RuleConfig<
  Record<string, RuleSelectorPropertyDisallowed | RuleSelectorPropertyDisallowed[]>,
  {
    message?: string | ((selector: string, property: string) => string)
    ignore?: ['keyframe-selectors']
  }
>

type SectorAnbNoUnmatchableOptions = RuleConfig<
  true,
  {
    message?: string | ((pseudoClass: string) => string)
  }
>

type SelectorAttributeNameDisallowedListOptions = RuleConfig<
  string | RegExp | (string | RegExp)[],
  {
    message?: string | ((name: string) => string)
  }
>

type SelectorAttributeOperatorAllowedListOptions = RuleConfig<
  SelectorAttributeOperator | RegExp | (SelectorAttributeOperator | RegExp)[],
  {
    message?: string | ((operator: string) => string)
  }
>

type SelectorAttributeOperatorDisallowedListOptions = RuleConfig<
  SelectorAttributeOperator | RegExp | (SelectorAttributeOperator | RegExp)[],
  {
    message?: string | ((operator: string) => string)
  }
>

type SelectorAttributeQuotesOptions = RuleConfig<
  'always' | 'never',
  {
    message?: string | ((value: string) => string)
  }
>

type SelectorClassPatternOptions = RuleConfig<
  string | RegExp,
  {
    /**
     * This option will resolve nested selectors with `&` interpolation.
     * @default false
     */
    resolveNestedSelectors?: boolean
    message?: string | ((selector: string, pattern: string) => string)
  }
>

type SelectorCombinatorAllowedListOptions = RuleConfig<
  SelectorCombinator | SelectorCombinator[],
  {
    message?: string | ((combinator: string) => string)
  }
>

type SelectorCombinatorDisallowedListOptions = RuleConfig<
  SelectorCombinator | SelectorCombinator[],
  {
    message?: string | ((combinator: string) => string)
  }
>

type SelectorDisallowedListIgnore = 'inside-block' | 'keyframe-selectors'

type SelectorDisallowedListOptions = RuleConfig<
  string | RegExp | (string | RegExp)[],
  {
    /**
     * Split selector lists into individual selectors.
     * @default false
     */
    splitList?: boolean
    /**
     * Ignore selectors that are inside a block.
     */
    ignore?: [SelectorDisallowedListIgnore]
    message?: string | ((selector: string) => string)
  }
>

type SelectorIdPatternOptions = RuleConfig<
  string | RegExp,
  {
    message?: string | ((selector: string, pattern: string) => string)
  }
>

type SelectorMaxAttributeOptions = RuleConfig<
  number,
  {
    ignoreAttributes?: (string | RegExp)[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxClassOptions = RuleConfig<
  number,
  {
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxCombinatorsOptions = RuleConfig<
  number,
  {
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxCompoundSelectorsOptions = RuleConfig<
  number,
  {
    ignoreSelectors?: (string | RegExp)[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxIdOptions = RuleConfig<
  number,
  {
    checkContextFunctionalPseudoClasses?: (string | RegExp)[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxPseudoClassOptions = RuleConfig<
  number,
  {
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxSpecificityOptions = RuleConfig<
  `${string},${string},${string}`,
  {
    ignoreSelectors?: (string | RegExp)[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxTypeOptions = RuleConfig<
  number,
  {
    /**
     * Discount child type selectors.
     */
    Ignore?: LiteralUnion<'child' | 'compounded' | 'custom-elements' | 'descendant' | 'next-sibling'>[]
    ignoreTypes?: (string | RegExp)[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorMaxUniversalOptions = RuleConfig<
  number,
  {
    /**
     * Ignore universal selectors that come after one of the specified combinators.
     */
    ignoreAfterCombinators?: SelectorCombinator[]
    message?: string | ((selector: string, max: number | string) => string)
  }
>

type SelectorNestedPatternOptions = RuleConfig<
  string | RegExp,
  {
    /**
     * Split selector lists into individual selectors.
     * @default false
     */
    splitList?: boolean
    message?: string | ((selector: string) => string)
  }
>

type SelectorNoQualifyingTypeIgnore = 'attribute' | 'class' | 'id'

type SelectorNoQualifyingTypeOptions = RuleConfig<
  true,
  {
    ignore?: SelectorNoQualifyingTypeIgnore[]
    message?: string | ((selector: string) => string)
  }
>

type SelectorNoVendorPrefixOptions = RuleConfig<
  true,
  {
    ignoreSelectors?: (string | RegExp)[]
    message?: string | ((selector: string) => string)
  }
>

type SelectorNotNotationOptions = RuleConfig<
  'simple' | 'complex',
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoClassAllowedListOptions = RuleConfig<
  SelectorPseudoClass | RegExpLike | (SelectorPseudoClass | RegExpLike)[],
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoClassDisallowedListOptions = RuleConfig<
  SelectorPseudoClass | RegExpLike | (SelectorPseudoClass | RegExpLike)[],
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoClassNoUnknownOptions = RuleConfig<
  true,
  {
    ignorePseudoClasses?: (string | RegExp)[]
    message?: string | ((selector: string) => string)
  }
>

type PseudoElement = SelectorPseudoElement | RegExp | `/${string}/`

type SelectorPseudoElementAllowedListOptions = RuleConfig<
  PseudoElement | PseudoElement[],
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoElementColonNotationOptions = RuleConfig<
  'single' | 'double',
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoElementDisallowed = SelectorPseudoElement | RegExpLike

type SelectorPseudoElementDisallowedListOptions = RuleConfig<
  SelectorPseudoElementDisallowed | SelectorPseudoElementDisallowed[],
  {
    message?: string | ((selector: string) => string)
  }
>

type SelectorPseudoElementNoUnknownOptions = RuleConfig<
  true,
  {
    ignorePseudoElements?: (string | RegExp)[]
    message?: string | ((selector: string) => string)
  }
>

type SelectorTypeCaseOptions = RuleConfig<
  'lower' | 'upper',
  {
    ignoreTypes?: (string | RegExp)[]
    message?: string | ((selector: string) => string)
  }
>

type SelectorTypeNoUnknownIgnore = LiteralUnion<'custom-elements' | 'default-namespace'>

type SelectorTypeNoUnknownOptions = RuleConfig<
  true,
  {
    ignore?: SelectorTypeNoUnknownIgnore[]
    ignoreNamespaces?: (string | RegExp)[]
    ignoreTypes?: (string | RegExp)[]
    message?: string | ((selector: string) => string)
  }
>

type ShorthandPropertyNoRedundantValuesOptions = RuleConfig<
  true,
  {
    message?: string | ((unexpected: string, expected: string) => string)
    /**
     * Ignore four-value shorthand declarations that could be shortened to three values when applied to edges.
     */
    ignore?: readonly ['four-into-three-edge-values']
  }
>

type StringNoNewlineOptions = RuleConfig<true, {
  ignore?: ('at-rule-preludes' | 'declaration-values')[]
  message?: string | (() => string)
}>

type SyntaxStringNoInvalidOptions = RuleConfig<true, {
  message?: string | ((syntaxString: string) => string)
}>

type TimeMinMillisecondsIgnore = 'delay'
type TimeMinMillisecondsOptions = RuleConfig<
  number,
  {
    /**
     * Ignore time values for an animation or transition delay.
     */
    ignore?: TimeMinMillisecondsIgnore[]
    message?: string | ((time: number) => string)
  }
>

type UnitAllowedListIgnoreProperties = Partial<
  Record<
    Unit,
    CSSPropertiesMap | RegExp | (CSSPropertiesMap | RegExp)[]
  >
>

type UnitAllowedListIgnoreFunctions =
  | CSSFunction | RegExpLike
  | (CSSFunction | RegExpLike)[]

type UnitAllowedListOptions = RuleConfig<
  Unit | Unit[],
  {
    ignoreProperties?: UnitAllowedListIgnoreProperties
    ignoreFunctions?: UnitAllowedListIgnoreFunctions
    message?: string | ((unit: number) => string)
  }
>

type UnitDisallowedListIgnoreProperties = Partial<
  Record<
    Unit,
    CSSPropertiesMap | RegExp | (CSSPropertiesMap | RegExp)[]
  >
>

type UnitDisallowedListIgnoreFunctions =
  | CSSFunction | RegExpLike
  | (CSSFunction | RegExpLike)[]

type UnitDisallowedListIgnoreMediaFeatureNames = Partial<
  Record<
    Unit,
    MediaFeature | RegExpLike | (MediaFeature | RegExpLike)[]
  >
>

type UnitDisallowedListOptions = RuleConfig<
  Unit | Unit[],
  {
    /**
     * Ignore units in the values of declarations with the specified properties.
     */
    ignoreProperties?: UnitDisallowedListIgnoreProperties
    /**
     * Ignore units for specific feature names.
     */
    ignoreFunctions?: UnitDisallowedListIgnoreFunctions
    /**
     * Ignore units that are inside of the specified functions.
     */
    ignoreMediaFeatureNames?: UnitDisallowedListIgnoreMediaFeatureNames

    message?: string | ((unit: number) => string)
  }
>

type UnitNoUnknownOptions = RuleConfig<
  true,
  {
    ignoreUnits?: (RegExp | string)[]
    ignoreFunctions?: (MediaFeature | RegExpLike)[]
    message?: string | ((unit: number) => string)
  }
>

type ValueKeywordCaseOptions = RuleConfig<
  'lower' | 'upper',
  {
    /**
     * Ignore case of keywords values.
     */
    ignoreKeywords?: (string | RegExp)[]
    /**
     * Ignore case of the values of the listed properties.
     */
    ignoreProperties?: (CSSPropertiesMap | RegExpLike)[]
    /**
     * Ignore case of the values inside the listed functions.
     */
    ignoreFunctions?: (CSSFunction | RegExpLike)[]
    /**
     * If `true`, this rule expects SVG keywords to be camel case when the primary option is "lower".
     * @default false
     */
    camelCaseSvgKeywords?: boolean
    message?: string | ((actual: number, expected: string) => string)
  }
>

type ValueNoVendorPrefixOptions = RuleConfig<
  true,
  {
    ignoreValues: string | RegExp | (string | RegExp)[]
    message?: string | ((actual: number, expected: string) => string)
  }
>

/**
 * Rules determine what the linter looks for and complains about.
 * There are {@link https://stylelint.io/user-guide/rules over 100 rules} built into Stylelint. No rules are turned on by default.
 */
interface StyleLintRules {
  /**
   * Specify percentage or number notation for alpha-values.
   *
   * ```scss
   * a { color: rgb(0 0 0 / 0.5) }
   * //                     ^^^
   * //                     This notation
   * ```
   *
   * ### Primary Options:
   * - `"number"`: Alpha-values must always use the number notation.
   * - `"percentage"`: Alpha-values must always use percentage notation.
   *
   * ### Optional Secondary Options:
   *
   * - `exceptProperties`: Reverse the primary option for matching properties.
   *
   * @see [alpha-value-notation](https://stylelint.io/user-guide/rules/alpha-value-notation)
   * @example
   * ```json
   * {
   *   "alpha-value-notation": ["number", { "exceptProperties": ["opacity"] }]
   * }
   * ```
   */
  'alpha-value-notation': AlphaValueNotationOptions
  /**
   * Disallow unknown annotations.
   *
   *
   * ```scss
   * a { color: green !important; }
   * //               ^^^^^^^^^^
   * //               This annotation
   * ```
   *
   * This rule considers annotations defined in the CSS Specifications, up to and including Editor's Drafts, to be known.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignoreAnnotations`
   *
   * @see [annotation-no-unknown](https://stylelint.io/user-guide/rules/annotation-no-unknown)
   */
  'annotation-no-unknown': AnnotationNoUnknownOptions
  /**
   * Specify a list of allowed at-rules.
   *
   * >```scss
   * >@keyframes name {}
   * >//^^^^^^^^
   * >//At-rules like this
   * >```
   *
   * ### Primary Options:
   * - `array | string`
   *
   * @see [at-rule-allowed-list](https://stylelint.io/user-guide/rules/at-rule-allowed-list)
   */
  'at-rule-allowed-list': AtRuleAllowedListOptions

  /**
   * Disallow unknown descriptors for at-rules.
   *
   * >```scss
   * >@counter-style foo {
   * >   unknown-descriptor: cyclic;
   * >// ^^^^^^^^^^^^^^^^^^
   * >// Descriptors like this
   * >}
   * >```
   * This rule considers descriptors defined in the CSS Specifications, up to and including Editor's Drafts, to be known.
   *
   * @see [at-rule-descriptor-no-unknown](https://stylelint.io/user-guide/rules/at-rule-descriptor-no-unknown)
   */
  'at-rule-descriptor-no-unknown': AtRuleDescriptorNoUnknownOptions

  /**
   * Disallow unknown values for descriptors within at-rules.
   *
   * >``` scss
   * >@counter-style foo {
   * >   system: unknown;
   * >//         ^^^^^^^
   * >//         Values like this
   * >}
   * >```
   *
   * This rule considers descriptors and values defined in the CSS Specifications, up to and including Editor's Drafts, to be known.
   *
   * @see [at-rule-descriptor-value-no-unknown](https://stylelint.io/user-guide/rules/at-rule-descriptor-value-no-unknown)
   */
  'at-rule-descriptor-value-no-unknown': AtRuleDescriptorValueNoUnknownOptions

  /**
   * Specify a list of disallowed at-rules.
   *
   * >```scss
   * >@keyframes name {}
   * >//^^^^^^^^
   * >//At-rules like this
   * >```
   * ### Primary Options:
   * - `array | string`
   *
   * @see [at-rule-disallowed-list](https://stylelint.io/user-guide/rules/at-rule-disallowed-list)
   */
  'at-rule-disallowed-list': AtRuleDisallowedListOptions

  /**
   * Require or disallow an empty line before at-rules.
   *
   * >```scss
   * >a {}
   * >          // ← This line
   * >@media {}
   * >```
   *
   * This rule ignores:
   * - at-rules that are the very first node in the source
   * - `@import` in Less.
   *
   * ### Primary Options:
   * - `"always"`: There must always be an empty line before at-rules.
   * - `"never"`: There must never be an empty line before at-rules.
   *
   * ### Optional Secondary Options:
   * - `except`
   * - `ignore`
   * - `ignoreAtRules`
   *
   * @see [at-rule-empty-line-before](https://stylelint.io/user-guide/rules/at-rule-empty-line-before)
   */
  'at-rule-empty-line-before': AtRuleEmptyLineBeforeOptions

  /**
   * Disallow deprecated at-rules.
   *
   * >``` scss
   * >@viewport {}
   * >//^^^^^^^
   * >//At-rules like this
   * >```
   *
   * This rule flags at-rules that were removed or deprecated after being in the CSS specifications, including editor drafts, and were subsequently either:
   *
   * - shipped in a stable version of a browser
   * - shipped by a developer channel/edition browser
   * - shipped but behind experimental flags
   * - polyfilled with some adoption before any browser actually shipped
   * - had an MDN page at one point in time
   *
   * @see [at-rule-no-deprecated](https://stylelint.io/user-guide/rules/at-rule-no-deprecated)
   */
  'at-rule-no-deprecated': AtRuleNoDeprecatedOptions

  /**
   * Disallow unknown at-rules.
   *
   * >```scss
   * >@unknown (max-width: 960px) {}
   * >//^^^^^^
   * >//At-rules like this
   * >```
   *
   * This rule considers at-rules defined in the CSS Specifications,
   * up to and including Editor's Drafts, to be known.
   *
   * ### Primary Options:
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignoreAtRules`
   *
   * @see [at-rule-no-unknown](https://stylelint.io/user-guide/rules/at-rule-no-unknown)
   */
  'at-rule-no-unknown': AtRuleNoUnknownOptions

  /**
   * Disallow vendor prefixes for at-rules.
   *
   * >```scss
   * >@-webkit-keyframes { 0% { top: 0; } }
   * >//^^^^^^
   * >//This prefix
   * >```
   *
   * ### Primary Options:
   * `true`
   *
   * This rule ignores non-standard vendor-prefixed at-rules that aren't handled by
   * {@link https://github.com/postcss/autoprefixer Autoprefixer}.
   *
   * @see [at-rule-no-vendor-prefix](https://stylelint.io/user-guide/rules/at-rule-no-vendor-prefix)
   */
  'at-rule-no-vendor-prefix': AtRuleNoVendorPrefixOptions

  /**
   * Disallow invalid preludes for at-rules.
   *
   * >```scss
   * >@property --foo {}
   * >//        ^^^^^
   * >//        Preludes like this
   * >```
   *
   * This rule considers preludes for at-rules defined within the CSS specifications, up to and including Editor's Drafts, to be valid.
   *
   * @see [at-rule-prelude-no-invalid](https://stylelint.io/user-guide/rules/at-rule-prelude-no-invalid)
   */
  'at-rule-prelude-no-invalid': AtRulePreludeNoInvalidOptions

  /**
   * Specify a list of required properties for an at-rule.
   *
   * ### Primary Options
   * `object`: `{ "at-rule-name": ["array", "of", "properties"] |"property" }`
   *
   * @see [at-rule-property-required-list](https://stylelint.io/user-guide/rules/at-rule-property-required-list)
   */
  'at-rule-property-required-list': AtRulePropertyRequiredListOptions

  /**
   * Disallow empty blocks.
   *
   * ```scss
   * a {  }
   * // ^^
   * // Blocks like this
   * ```
   *
   * ### Primary Options:
   * `true`
   *
   * @see [block-no-empty](https://stylelint.io/user-guide/rules/block-no-empty)
   */
  'block-no-empty': BlockNoEmptyOptions

  /**
   * Specify alias notation for color-functions
   *
   * ```scss
   * a { color: rgb(0 0 0 / 0.2) }
   * //         ^^^
   * //         This notation
   * ```
   *
   * Color functions `rgb()` and `hsl()` have aliases `rgba()` and `hsla()`. Those are exactly equivalent, and [it's preferable](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb) to use the first variant without `a`.
   *
   * ### Primary Options
   * - `'without-alpha'`: Applicable color-functions must always use the without alpha notation.
   * - `'with-alpha'`: Applicable color-functions must always use with alpha notation.
   *
   * @see [color-function-alias-notation](https://stylelint.io/user-guide/rules/color-function-alias-notation)
   */
  'color-function-alias-notation': ColorFunctionAliasNatationOptions

  /**
   * Specify modern or legacy notation for color-functions.
   *
   * ```scss
   * a { color: rgb(0 0 0 / 0.2) }
   * //         ^^^
   * //         This notation
   * ```
   *
   * Modern color-functions use a comma-free syntax because functions in CSS are used to group/name a syntax chunk.
   * They should work by the same rules that CSS grammar does in general:
   * values are optional and re-orderable when possible, space-separated, and commas are used to separate repetitions only.
   *
   * For legacy reasons, `rgb()` and `hsl()` also supports an alternate syntax that separates all of its arguments with commas.
   * Also for legacy reasons, the `rgba()` and `hsla()` functions exist using the same comma-based syntax.
   *
   * ### Primary Options
   * - `"modern"`: Applicable color-functions must always use modern notation.
   * - `"legacy"`: Applicable color-functions must always use the legacy notation.
   *
   * ### Optional Secondary Options
   * - `ignore`
   *
   * @see [color-function-notation](https://stylelint.io/user-guide/rules/color-function-notation)
   */
  'color-function-notation': ColorFunctionNatationOptions

  /**
   * Require or disallow alpha channel for hex colors.
   *
   * ```scss
   * a { color: #fffa }
   * //             ^
   * //           This alpha channel
   * ```
   *
   * ### Primary Options
   * - `"always"`
   * - `"never"`
   *
   * @see [color-hex-alpha](https://stylelint.io/user-guide/rules/color-hex-alpha)
   */
  'color-hex-alpha': ColorHexAlphaOptions

  /**
   * Specify short or long notation for hex colors.
   *
   * ```scss
   * a { color: #fff }
   * //         ^^^^
   * //         This hex color
   * ```
   *
   * ### Primary Options
   * - `"short"`
   * - `"long"`
   *
   * @see [color-hex-length](https://stylelint.io/user-guide/rules/color-hex-length)
   */
  'color-hex-length': ColorHexLengthOptions

  /**
   * Require (where possible) or disallow named colors.
   *
   * ```scss
   * a { color: black }
   * //         ^^^^^
   * //         This named color
   * ```
   *
   * This rule ignores `$sass` and `@less` variable syntaxes.
   *
   * ### Primary Options
   * - `"always-where-possible"`: Colors must always, where possible, be named.
   *   This will complain if a hex (3, 4, 6 and 8 digit), `rgb()`, `rgba()`, `hsl()`,
   *   `hsla()`, `hwb()` or `gray()` color can be represented as a named color.
   * - `"never"`: Colors must never be named.
   *
   * ### Optional Secondary Options
   * - `ignore`
   * - `ignoreProperties`
   *
   * @see [color-named](https://stylelint.io/user-guide/rules/color-named)
   */
  'color-named': ColorNamedOptions

  /**
   * Disallow hex colors.
   *
   * ```scss
   * a { color: #333 }
   * //         ^^^^
   * //         This hex color
   * ```
   *
   * ### Primary Options
   * `true`
   *
   * @see [color-no-hex](https://stylelint.io/user-guide/rules/color-no-hex)
   */
  'color-no-hex': ColorNoHexOptions

  /**
   * Disallow invalid hex colors.
   *
   * ```scss
   * a { color: #y3 }
   * //         ^^^
   * //         This hex color
   * ```
   *
   * ### Primary Options
   * `true`
   *
   * Longhand hex colors can be either 6 or 8 (with alpha channel) hexadecimal characters.
   * And their shorthand variants are 3 and 4 characters respectively.
   *
   * @see [color-no-invalid-hex](https://stylelint.io/user-guide/rules/color-no-invalid-hex)
   */
  'color-no-invalid-hex': ColorNoInvalidHexOptions

  /**
   * Require or disallow an empty line before comments.
   *
   * ```scss
   * a {}
   *                 // ←
   * \/* comment *\/ // ↑
   * //                 ↑
   * //              This line
   * ```
   *
   * This rule ignores:
   * - comments that are the very first node in the source
   * - shared-line comments
   * - single-line comments with `//` (when you're using a custom syntax that supports them)
   * - comments within selector and value lists
   *
   * ### Primary Options
   * - `"always"`: There must always be an empty line before comments.
   * - `"never"`: There must never be an empty line before comments.
   *
   * ### Optional Secondary Options
   *
   * - `except`
   * - `ignore`
   * - `ignoreComments`
   *
   * @see [comment-empty-line-before](https://stylelint.io/user-guide/rules/comment-empty-line-before)
   */
  'comment-empty-line-before': CommentEmptyLineBeforeOptions

  /**
   * Disallow empty comments.
   *
   * ```scss
   * \/*   *\/
   * // ^^^
   * // Comments like this
   * ```
   *
   * This rule ignores SCSS-like comments.
   *
   * ### Primary Options
   * `true`
   *
   * @see [comment-no-empty](https://stylelint.io/user-guide/rules/comment-no-empty)
   */
  'comment-no-empty': CommentNoEmptyOptions

  /**
   * Specify a pattern for comments.
   *
   * ```scss
   * \/*  comment *\/
   *      ^^^^^^^
   *      The pattern of this
   * ```
   *
   * ### Primary Options
   *
   * `RegExp | string`
   *
   * A string will be translated into a RegExp like so `new RegExp(yourString)` — so be sure to escape properly.
   *
   * @see [comment-pattern](https://stylelint.io/user-guide/rules/comment-pattern)
   */
  'comment-pattern': CommentPatternOptions

  /**
   * Require or disallow whitespace on the inside of comment markers.
   *
   * ```scss
   * \/* comment *\/
   *    ^       ^
   *    The space inside these two markers
   * ```
   *
   * Any number of asterisks are allowed at the beginning or end of the comment.
   *
   * ### Primary Options
   * - `"always"`: There must always be whitespace inside the markers.
   * - `"never"`: There must never be whitespace on the inside the markers.
   *
   * @see [comment-whitespace-inside](https://stylelint.io/user-guide/rules/comment-whitespace-inside)
   */
  'comment-whitespace-inside': CommentWhitespaceInsideOptions

  /**
   * Specify a list of disallowed words within comments.
   *
   * ```scss
   * \/* words within comments *\/
   * //  ^^^^^ ^^^^^^ ^^^^^^^^
   * //  These three words
   * ```
   *
   * ### Primary Option
   * `(string | RegExp)[]`
   *
   * @see [comment-word-disallowed-list](https://stylelint.io/user-guide/rules/comment-word-disallowed-list)
   */
  'comment-word-disallowed-list': CommentWordDisallowedListOptions

  /**
   * Specify a pattern for container names.
   *
   * >```scss
   * >@container foo (width > 400px) {}
   * >//         ^^^
   * >//         The pattern of this
   * >```
   *
   * ### Primary Options
   * `RegExp | string`: A string will be translated into a `RegExp` like so `new RegExp(yourString)` — so be sure to escape properly.
   *
   * @see [container-name-pattern](https://stylelint.io/user-guide/rules/container-name-pattern)
   */
  'container-name-pattern': ContainerNamePatternOptions

  /**
   * Specify a pattern for custom media query names.
   *
   * >```scss
   * >@custom-media --foo (max-width: 30em);
   * >//            ^^^^^
   * >//            The pattern of this
   * >```
   *
   * ### Primary Options
   * `RegExp | string`
   *
   * A string will be translated into a RegExp like so `new RegExp(yourString)` — so be sure to escape properly.
   *
   * @see [custom-media-pattern](https://stylelint.io/user-guide/rules/custom-media-pattern)
   */
  'custom-media-pattern': CustomMediaPatternOptions

  /**
   * Require or disallow an empty line before custom properties.
   *
   * ```scss
   * a {
   *   top: 10px;
   *                  // This line
   *   --color: pink;
   * }
   * ```
   *
   * ### Primary Options
   * - `"always"`
   * - `"never"`
   *
   * ## Optional Secondary Options
   * - `except`
   * - `ignore`
   *
   * @see [custom-property-empty-line-before](https://stylelint.io/user-guide/rules/custom-property-empty-line-before)
   */
  'custom-property-empty-line-before': CustomPropertyEmptyLineBeforeOptions

  /**
   * Disallow missing var function for custom properties.
   *
   * ```scss
   * :root { --foo: red; }
   *  a { color: --foo; }
   * //          ^^^^^
   * //          This custom property
   * ```
   *
   * This rule only reports custom properties that are defined within the same source.
   *
   * @see [custom-property-no-missing-var-function](https://stylelint.io/user-guide/rules/custom-property-no-missing-var-function)
   */
  'custom-property-no-missing-var-function': CustomPropertyNoMissingVarFunctionOptions

  /**
   * Specify a pattern for custom properties.
   *
   * ```scss
   * a { --foo-: 1px; }
   * //  ^^^^^^
   * //  The pattern of this
   * ```
   *
   * ### Primary Options:
   *
   * `RegExp | string`
   *
   * A string will be translated into a RegExp like so `new RegExp(yourString)` — so be sure to escape properly.
   *
   * @see [custom-property-pattern](https://stylelint.io/user-guide/rules/custom-property-pattern)
   */
  'custom-property-pattern': CustomPropertyPatternOptions

  /**
   * Disallow duplicate custom properties within declaration blocks.
   *
   * ```scss
   * a { --custom-property: pink; --custom-property: orange; }
   * //  ^^^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^
   * //  These duplicated custom properties
   * ```
   *
   * This rule is case-sensitive.
   *
   * ### Primary Options
   * `true`
   *
   * @see [declaration-block-no-duplicate-custom-properties](https://stylelint.io/user-guide/rules/declaration-block-no-duplicate-custom-properties)
   */
  'declaration-block-no-duplicate-custom-properties': DeclarationBlockNoDuplicateCustomPropertiesOptions

  /**
   * Disallow duplicate properties within declaration blocks.
   *
   * ```scss
   * a { color: pink; color: orange; }
   * //  ^^^^^        ^^^^^
   * // These duplicated properties
   * ```
   *
   * This rule ignores variables (`$sass`, `@less`, `--custom-property`).
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignore`
   * - `ignoreProperties`
   *
   * @see [declaration-block-no-duplicate-properties](https://stylelint.io/user-guide/rules/declaration-block-no-duplicate-properties)
   */
  'declaration-block-no-duplicate-properties': DeclarationBlockNoDuplicatePropertiesOptions

  /**
   * Disallow redundant longhand properties within declaration-block.
   *
   * ```scss
   * a {
   *   padding-top: 1px;    // ←
   *   padding-right: 2px;  // ←
   *   padding-bottom: 3px; // ←
   *   padding-left: 4px;   // ←
   * //                    These longhand properties
   * }
   * ```
   * The longhand properties in the example above can be more concisely written as:
   * ```
   * a { padding: 1px 2px 3px 4px; }
   * ```
   *
   * This rule will only complain if you've used the longhand equivalent of all the properties
   * that the shorthand will set and if their values are not {@link https://www.w3.org/TR/css-values/#common-keywords CSS-wide keywords} like initial, inherit etc.
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreShorthands`
   * - `ignoreLonghands`
   *
   * @see [declaration-block-no-redundant-longhand-properties](https://stylelint.io/user-guide/rules/declaration-block-no-redundant-longhand-properties)
   */
  'declaration-block-no-redundant-longhand-properties': DeclarationBlockNoRedundantLonghandPropertiesOptions

  /**
   * Disallow shorthand properties that override related longhand properties.
   *
   * ```scss
   * a { background-repeat: repeat; background: green; }
   * //                             ^^^^^^^^^^
   * //     This overrides the longhand property before it
   * ```
   *
   * In almost every case, this is just an authorial oversight. For more about this behavior,
   * see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties MDN's documentation of shorthand properties}.
   *
   * ### Primary Options
   * `true`
   *
   * @see [declaration-block-no-shorthand-property-overrides](https://stylelint.io/user-guide/rules/declaration-block-no-shorthand-property-overrides)
   */
  'declaration-block-no-shorthand-property-overrides': DeclarationBlockNoShorthandPropertyOverridesOptions

  /**
   * Limit the number of declarations within a single-line declaration block.
   *
   * ```scss
   * a { color: pink; top: 0; }
   * //  ^            ^
   * //  The number of these declarations
   * ```
   *
   * ### Primary Options:
   *
   * `int`: Maximum number of declarations allowed.
   * @see [declaration-block-single-line-max-declarations](https://stylelint.io/user-guide/rules/declaration-block-single-line-max-declarations)
   */
  'declaration-block-single-line-max-declarations': DeclarationBlockSingleLineMaxDeclarationsOptions

  /**
   * Require or disallow an empty line before declarations.
   *
   * ```scss
   * a {
   *   --foo: pink;
   * //               ← This line
   *   top: 15px;
   * }
   * ```
   *
   * This rule only applies to standard property declarations.
   * Use the {@link https://github.com/stylelint/stylelint/blob/main/lib/rules/custom-property-empty-line-before/README.md custom-property-empty-line-before}
   * rule for custom property declarations.
   *
   * ### Primary Options
   * - `"always"`
   * - `"never"`
   *
   * ### Optional Secondary Options
   * - `except`
   * - `ignore`
   *
   * @see [declaration-empty-line-before](https://stylelint.io/user-guide/rules/declaration-empty-line-before)
   */
  'declaration-empty-line-before': DeclarationEmptyLineBeforeOptions

  /**
   * Disallow `!important` within declarations.
   *
   * ```scss
   * a { color: pink !important; }
   * //              ^^^^^^^^^^
   * //           This `!important`
   * ```
   *
   * If you always want `!important` in your declarations, e.g.
   * if you're writing {@link https://userstyles.org/ user styles}, you can safely add them using
   * {@link https://github.com/crimx/postcss-safe-important postcss-safe-important}.
   *
   * ### Primary Options
   * `true`
   *
   * @see [declaration-no-important](https://stylelint.io/user-guide/rules/declaration-no-important)
   */
  'declaration-no-important': DeclarationNoImportantOptions

  /**
   * Limit the number of values for a list of properties within declarations.
   *
   * ### Primary Options:
   *
   * `object`: `{ "unprefixed-property-name": int }`
   * ```json
   * {
   *   "border": 2,
   *   "/^margin/": 2,
   * }
   * ```
   *
   * If a property name is surrounded with `"/"` (e.g. `"/^margin/"`),
   * it is interpreted as a regular expression. This allows, for example,
   * easy targeting of shorthands: `/^margin/` will match `margin`, `margin-top`, `margin-inline`, etc.
   *
   * @see [declaration-property-max-values](https://stylelint.io/user-guide/rules/declaration-property-max-values)
   */
  'declaration-property-max-values': DeclarationPropertyMaxValuesOptions

  /**
   * Specify a list of allowed property and unit pairs within declarations.
   *
   * ```scss
   * a { width: 100px; }
   * //  ^^^^^     ^^
   * // These properties and these units
   * ```
   *
   * ### Primary Options
   *
   * `object`: `{ "unprefixed-property-name": ["array", "of", "units"]|"unit" }`
   *
   * ```json
   * {
   *   "font-size": ["em", "px"],
   *   "/^animation/": "s",
   * }
   * ```
   *
   * ### Optional Secondary Options
   * - `ignore`
   *
   * If a property name is surrounded with `"/"` (e.g. `"/^animation/"`),
   * it is interpreted as a regular expression. This allows, for example,
   * easy targeting of shorthands: `/^animation/` will match `animation`, `animation-duration`, `animation-timing-function`, etc.
   *
   * @see [declaration-property-unit-allowed-list](https://stylelint.io/user-guide/rules/declaration-property-unit-allowed-list)
   */
  'declaration-property-unit-allowed-list': DeclarationPropertyUnitAllowedListOptions

  /**
   * Specify a list of disallowed property and unit pairs within declarations.
   *
   * ```scss
   * a { width: 100px; }
   * //  ^^^^^     ^^
   * //  These properties and these units
   * ```
   *
   * ### Primary Options
   *
   * `object`: `{ "unprefixed-property-name": ["array", "of", "units"]|"unit" }`
   *
   * ```json
   * {
   *   "font-size": ["em", "px"],
   *   "/^animation/": "s",
   * }
   * ```
   *
   * If a property name is surrounded with `"/"` (e.g. `"/^animation/"`),
   * it is interpreted as a regular expression. This allows, for example,
   * easy targeting of shorthands: `/^animation/` will match `animation`, `animation-duration`, `animation-timing-function`, etc.
   *
   * @see [declaration-property-unit-disallowed-list](https://stylelint.io/user-guide/rules/declaration-property-unit-disallowed-list)
   */
  'declaration-property-unit-disallowed-list': DeclarationPropertyUnitDisallowedListOptions

  /**
   * Specify a list of allowed property and value pairs within declarations.
   *
   * ```scss
   * a { text-transform: uppercase; }
   * //  ^^^^^^^^^^^^^^  ^^^^^^^^^
   * //  These properties and these values
   * ```
   *
   * ### Primary Options:
   *
   * `object`: `{ "unprefixed-property-name": ["array", "of", "values", "/regex/", /regex/] |"value" | "/regex/" | /regex/ }`
   *
   * ```json
   * {
   *   "transform": ["/scale/"],
   *   "/color/": "/^green/"
   * }
   * ```
   *
   * If a property name is found in the object, only the listed property values are allowed.
   * This rule complains about all non-matching values.
   * (If the property name is not included in the object, anything goes.)
   *
   * If a property name is surrounded with` "/"` (e.g. `"/^animation/"`),
   * it is interpreted as a regular expression.
   * This allows, for example, easy targeting of shorthands:
   * `/^animation/` will match `animation`, `animation-duration`, `animation-timing-function`, etc.
   *
   * The same goes for values. Keep in mind that a regular expression value is matched against the
   * entire value of the declaration, not specific parts of it.
   * For example, a value like `"10px solid rgba( 255 , 0 , 0 , 0.5 )"` will not match `"/^solid/"`
   *  (notice beginning of the line boundary) but will match `"/\\s+solid\\s+/"` or `"/\\bsolid\\b/"`.
   *
   * Be careful with regex matching not to accidentally consider quoted string values and `url()` arguments.
   * For example, `"/red/"` will match value such as `"1px dotted red"` as well as `"\"red\""` and `"white url(/mysite.com/red.png)"`.
   *
   * @see [declaration-property-value-allowed-list](https://stylelint.io/user-guide/rules/declaration-property-value-allowed-list)
   */
  'declaration-property-value-allowed-list': DeclarationPropertyValueAllowedListOptions

  /**
   * Specify a list of disallowed property and value pairs within declarations.
   *
   * ```scss
   * a { text-transform: uppercase; }
   * //  ^^^^^^^^^^^^^^  ^^^^^^^^^
   * //  These properties and these values
   * ```
   *
   * ### Primary Options:
   *
   * `object`: `{ "unprefixed-property-name": ["array", "of", "values", "/regex/", /regex/] |"value" | "/regex/" | /regex/ }`
   *
   * ```json
   * {
   *   "transform": ["/scale3d/", "/rotate3d/", "/translate3d/"],
   *   "/^animation/": ["/ease/"]
   * }
   * ```
   *
   * If a property name is surrounded with` "/"` (e.g. `"/^animation/"`),
   * it is interpreted as a regular expression.
   * This allows, for example, easy targeting of shorthands:
   * `/^animation/` will match `animation`, `animation-duration`, `animation-timing-function`, etc.
   *
   * The same goes for values. Keep in mind that a regular expression value is matched against the
   * entire value of the declaration, not specific parts of it.
   * For example, a value like `"10px solid rgba( 255 , 0 , 0 , 0.5 )"` will not match `"/^solid/"`
   *  (notice beginning of the line boundary) but will match `"/\\s+solid\\s+/"` or `"/\\bsolid\\b/"`.
   *
   * Be careful with regex matching not to accidentally consider quoted string values and `url()` arguments.
   * For example, `"/red/"` will match value such as `"1px dotted red"` as well as `"\"red\""` and `"white url(/mysite.com/red.png)"`.
   *
   * @see [declaration-property-value-disallowed-list](https://stylelint.io/user-guide/rules/declaration-property-value-disallowed-list)
   */
  'declaration-property-value-disallowed-list': DeclarationPropertyValueDisallowedListOptions

  /**
   * Disallow deprecated keywords for properties within declarations.
   *
   * ```scss
   * a { color: ThreeDDarkShadow; }
   * //  ^^^^^  ^^^^^^^^^^^^^^^^
   * // property and value pairs like these
   * ```
   *
   * This rule flags keywords that were removed or deprecated after being in the CSS specifications, including editor drafts, and were subsequently either:
   * - shipped in a stable version of a browser
   * - shipped by a developer channel/edition browser
   * - shipped but behind experimental flags
   * - polyfilled with some adoption before any browser actually shipped
   * - had an MDN page at one point in time
   *
   * @see [declaration-property-value-keyword-no-deprecated](https://stylelint.io/user-guide/rules/declaration-property-value-keyword-no-deprecated)
   */
  'declaration-property-value-keyword-no-deprecated': DeclarationPropertyValueKeywordNoDeprecatedOptions

  /**
   * Disallow unknown values for properties within declarations.
   *
   * ```scss
   * a { top: unknown; }
   * //  ^^^  ^^^^^^^
   * //  property and value pairs like these
   * ```
   *
   * This rule considers values for properties defined within the CSS specifications to be known.
   * You can use the `propertiesSyntax` and `typesSyntax` secondary options to extend the syntax.
   *
   * This rule is only appropriate for CSS. You should not turn it on for CSS-like languages,
   * such as Sass or Less, as they have their own syntaxes.
   *
   * This rule is experimental with some false negatives that we'll patch in minor releases.
   *
   * It sometimes overlaps with:
   * - color-no-invalid-hex
   * - function-no-unknown
   * - string-no-newline
   * - unit-no-unknown
   *
   * If duplicate problems are flagged, you can turn off the corresponding rule.
   *
   * ### Primary Option
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreProperties`
   * - `propertiesSyntax`
   * - `typesSyntax`
   *
   * @see [declaration-property-value-no-unknown](https://stylelint.io/user-guide/rules/declaration-property-value-no-unknown)
   */
  'declaration-property-value-no-unknown': DeclarationPropertyValueNoUnknownOptions

  /**
   * Require or disallow quotes for font family names.
   *
   * ```scss
   * a { font-family: "Times New Roman", 'Ancient Runes', serif; }
   * //               ^               ^  ^             ^
   * //               These quotation marks and this one
   * ```
   *
   * This rule checks the `font` and `font-family` properties.
   *
   * This rule ignores `$sass`, `@less`, and `var(--custom-property)` variable syntaxes.
   *
   * ### Primary Options
   *
   * - `"always-unless-keyword"`: Expect quotes around every font family name that is not a keyword.
   * - `"always-where-required"`: Expect quotes only when quotes are required according to the criteria above, and disallow quotes in all other cases.
   * - `"always-where-recommended"`: Expect quotes only when quotes are recommended according to the criteria above, and disallow quotes in all other cases. (This includes all cases where quotes are required, as well.)
   *
   * @see [font-family-name-quotes](https://stylelint.io/user-guide/rules/font-family-name-quotes)
   */
  'font-family-name-quotes': FontFamilyNameQuotesOptions

  /**
   * Disallow duplicate names within font families.
   *
   * ```scss
   * a { font-family: serif, serif; }
   * //               ^^^^^  ^^^^^
   * //               These font family names
   * ```
   *
   * This rule checks the `font` and `font-family` properties.
   *
   * This rule ignores `$sass`, `@less`, and `var(--custom-property)` variable syntaxes.
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreFontFamilyNames`
   *
   * @see [font-family-no-duplicate-names](https://stylelint.io/user-guide/rules/font-family-no-duplicate-names)
   */
  'font-family-no-duplicate-names': FontFamilyNoDuplicateNamesOptions

  /**
   * Disallow a missing generic family keyword within font families.
   *
   * ```scss
   * a { font-family: Arial, sans-serif; }
   * //                      ^^^^^^^^^^
   * //        An example of generic family name
   * ```
   *
   * The generic font family can be:
   * - placed anywhere in the font family list
   * - omitted if a keyword related to property inheritance or a system font is used
   *
   * This rule checks the font and font-family properties.
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreFontFamilies`
   *
   * @see [font-family-no-missing-generic-family-keyword](https://stylelint.io/user-guide/rules/font-family-no-missing-generic-family-keyword)
   */
  'font-family-no-missing-generic-family-keyword': FontFamilyNoMissingGenericFamilyKeywordOptions

  /**
   * Require numeric or named (where possible) `font-weight` values.
   *
   * ```scss
   * a { font-weight: bold; }
   * //               ^^^^
   * a { font: italic small-caps 600 16px/3 cursive; }
   * //                          ^^^
   * \@font-face { font-weight: normal bold; }
   * //                         ^^^^^^ ^^^^
   * ```
   *
   * This rule ignores `$sass`, `@less`, and `var(--custom-property)` variable syntaxes.
   *
   * ### Primary Options:
   * - `"numeric"`: `font-weight` values must always be numbers.
   * - `"named-where-possible"`: `font-weight` values must always be keywords when an appropriate keyword is available. This means that only `400` and `700` will be rejected, because those are the only numbers with keyword equivalents (`normal` and `bold`).
   *
   * ### Optional Secondary Options
   *
   * - `ignore`
   *
   * @see [font-weight-notation](https://stylelint.io/user-guide/rules/font-weight-notation)
   */
  'font-weight-notation': FontWeightNotationOptions

  /**
   * Specify a list of allowed functions.
   *
   * ```scss
   * a { transform: scale(1); }
   * //             ^^^^^
   * //             This function
   * ```
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * If a string is surrounded with `"/"` (e.g. `"/^rgb/"`), it is interpreted as a regular expression.
   *
   * @see [function-allowed-list](https://stylelint.io/user-guide/rules/function-allowed-list)
   */
  'function-allowed-list': FunctionAllowedListOptions

  /**
   * Disallow invalid unspaced operator within calc functions.
   *
   * ```scss
   * a { top: calc(1px + 2px); }
   * //                ^
   * //         The space around this operator
   * ```
   *
   * This rule checks that there is a single whitespace or a newline plus indentation
   * before the `+` or `-` operator, and a single whitespace or a newline after that operator.
   *
   * ### Primary Options
   * `true`
   *
   * @see [function-calc-no-unspaced-operator](https://stylelint.io/user-guide/rules/function-calc-no-unspaced-operator)
   */
  'function-calc-no-unspaced-operator': FunctionCalcNoUnspacedOperatorOptions

  /**
   * Specify a list of disallowed functions.
   *
   * ```scss
   * a { transform: scale(1); }
   * //             ^^^^^
   * //      This function
   * ```
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * If a string is surrounded with `"/"` (e.g. `"/^rgb/"`), it is interpreted as a regular expression.
   *
   * @see [function-disallowed-list](https://stylelint.io/user-guide/rules/function-disallowed-list)
   */
  'function-disallowed-list': FunctionDisallowedListOptions

  /**
   * Disallow non-standard direction values for linear gradient functions.
   *
   * ```scss
   * .foo { background: linear-gradient(to top, #fff, #000); }
   * //                                 ^^^^^^
   * //     This (optional) first argument is the "direction"
   * ```
   *
   * A valid and standard direction value is one of the following:
   * - an angle
   * - `to` plus a side-or-corner (`to top`, `to bottom`, `to left`, `to right`; `to top right`, `to right top`, `to bottom left`, etc.)
   *
   * A common mistake (matching outdated non-standard syntax) is to use just a side-or-corner without the preceding `to`.
   *
   * ### Primary Options
   * `true`
   *
   * @see [function-linear-gradient-no-nonstandard-direction](https://stylelint.io/user-guide/rules/function-linear-gradient-no-nonstandard-direction)
   */
  'function-linear-gradient-no-nonstandard-direction': FunctionLinearGradientNoNonstandardDirectionOptions

  /**
   * Specify lowercase or uppercase for function names.
   * ```scss
   * a { width: calc(5% - 10em); }
   * //         ^^^^
   * //      This function
   * ```
   *
   * Camel case function names, e.g. `translateX`, are accounted for when the `lower` option is used.
   *
   * ### Primary Options:
   * - "lower"
   * - "upper"
   *
   * ### Optional Secondary Options
   * -`ignoreFunctions`
   *
   * @see [function-name-case](https://stylelint.io/user-guide/rules/function-name-case)
   */
  'function-name-case': FunctionNameCaseOptions

  /**
   * Disallow unknown functions.
   *
   * ```scss
   * a { transform: unknown(1); }
   * //             ^^^^^^^
   * //            Functions like this
   * ```
   *
   * This rule considers functions defined in the CSS Specifications to be known.
   *
   * This rule ignores double-dashed custom functions, e.g. `--custom-function()`.
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreFunctions`
   *
   * @see [function-no-unknown](https://stylelint.io/user-guide/rules/function-no-unknown)
   */
  'function-no-unknown': FunctionNoUnknownOptions

  /**
   * Disallow scheme-relative urls.
   *
   * ```scss
   * a { background-image: url('//www.google.com/file.jpg'); }
   * //                         ^^
   * //                 This scheme-relative url
   * ```
   *
   * A {@link https://url.spec.whatwg.org/#syntax-url-scheme-relative scheme-relative url}
   * is a url that begins with `//` followed by a host.
   *
   * This rule ignores url arguments that are variables (`$sass`, `@less`, `--custom-property`).
   *
   * ### Primary Options
   * `true`
   *
   * @see [function-url-no-scheme-relative](https://stylelint.io/user-guide/rules/function-url-no-scheme-relative)
   */
  'function-url-no-scheme-relative': FunctionUrlNoSchemeRelativeOptions

  /**
   * Require or disallow quotes for urls.
   *
   * ```scss
   * a { background: url("x.jpg") }
   * //                  ^     ^
   * //                 These quotes
   * ```
   *
   * ### Primary Options:
   * - `"always"`: Urls must always be quoted.
   * - `"never"`:  Urls must never be quoted.
   *
   * ### Optional Secondary Options
   * - `except`
   *
   * @see [function-url-quotes](https://stylelint.io/user-guide/rules/function-url-quotes)
   */
  'function-url-quotes': FunctionUrlQuotesOptions

  /**
   * Specify a list of allowed URL schemes.
   *
   * ```scss
   * a { background-image: url('http://www.example.com/file.jpg'); }
   * //                         ^^^^^
   * //                        This URL scheme
   * ```
   *
   * A {@link https://url.spec.whatwg.org/#syntax-url-scheme URL scheme} consists of alphanumeric, `+`, `-`, and `.` characters. It can appear at the start of a URL and is followed by `:`.
   *
   * This rule ignores:
   * - URL arguments without an existing URL scheme
   * - URL arguments with variables or variable interpolation (`$sass`, `@less`, `--custom-property`, `#{$var}`, `@{var}`, `$(var)`)
   *
   * ### Primary Options
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [function-url-scheme-allowed-list](https://stylelint.io/user-guide/rules/function-url-scheme-allowed-list)
   */
  'function-url-scheme-allowed-list': FunctionUrlSchemeAllowedListOptions

  /**
   * Specify a list of disallowed URL schemes.
   *
   * ```scss
   * a { background-image: url('http://www.example.com/file.jpg'); }
   * //                         ^^^^^
   * //                        This URL scheme
   * ```
   *
   *  A {@link https://url.spec.whatwg.org/#syntax-url-scheme URL scheme} consists of alphanumeric, `+`, `-`, and `.` characters. It can appear at the start of a URL and is followed by `:`.
   *
   * This rule ignores:
   * - URL arguments without an existing URL scheme
   * - URL arguments with variables or variable interpolation (`$sass`, `@less`, `--custom-property`, `#{$var}`, `@{var}`, `$(var)`)
   *
   * ### Primary Options
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [function-url-scheme-disallowed-list](https://stylelint.io/user-guide/rules/function-url-scheme-disallowed-list)
   */
  'function-url-scheme-disallowed-list': FunctionUrlSchemeDisallowedListOptions

  /**
   * Specify number or angle notation for degree hues.
   *
   * ```scss
   * a { color: hsl(198deg 28% 50%) }
   * //             ^^^^^^
   * //           This notation
   * ```
   *
   * Because hues are so often given in degrees, a hue can also be given as a number,
   * which is interpreted as a number of degrees.
   *
   * ### Primary Options:
   * - `"angle"`: Degree hues must always use angle notation.
   * - `"number"`: Degree hues must always use the number notation.
   *
   * @see [hue-degree-notation](https://stylelint.io/user-guide/rules/hue-degree-notation)
   */
  'hue-degree-notation': HueDegreeNotationOptions

  /**
   * Specify string or URL notation for `@import` rules.
   *
   * ```scss
   * \@import url("x.jpg");
   * //       ^^^^       ^
   * //     This notation
   * ```
   *
   * ### Primary Options:
   * - "string"
   * - "url"
   *
   * @see [import-notation](https://stylelint.io/user-guide/rules/import-notation)
   */
  'import-notation': ImportNotationOptions

  /**
   * Disallow duplicate selectors within keyframe blocks.
   *
   * ```scss
   * \@keyframes foo { 0% {} 0% {} }
   * //                     ^
   * //        This duplicate selector
   * ```
   *
   * This rule is case-insensitive.
   *
   * @see [keyframe-block-no-duplicate-selectors](https://stylelint.io/user-guide/rules/keyframe-block-no-duplicate-selectors)
   */
  'keyframe-block-no-duplicate-selectors': KeyframeBlockNoDuplicateSelectorsOptions

  /**
   * Disallow invalid !important within keyframe declarations.
   *
   * Using `!important` within keyframes declarations is
   * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/@keyframes#!important_in_a_keyframe completely ignored in some browsers}.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [keyframe-declaration-no-important](https://stylelint.io/user-guide/rules/keyframe-declaration-no-important)
   */
  'keyframe-declaration-no-important': KeyframeDeclarationNoImportantOptions

  /**
   * Specify keyword or percentage notation for keyframe selectors.
   *
   * ```scss
   * \@keyframes foo {
   *   from { opacity: 0 }
   *   to { opacity: 1 !important }
   * //                ^^^^^^^^^^
   * }
   * ```
   *
   * The keyword `from` is equivalent to the value `0%`.
   * The keyword `to` is equivalent to the value `100%`.
   *
   * ### Primary Options:
   * - `"keyword"`: Keyframe selectors must always use the keyword notation.
   * - `"percentage"`: Keyframe selectors must always use the percentage notation.
   * - `"percentage-unless-within-keyword-only-block"`: Keyframe selectors must use the percentage notation unless within a keyword-only block.
   *
   * @see [keyframe-selector-notation](https://stylelint.io/user-guide/rules/keyframe-selector-notation)
   */
  'keyframe-selector-notation': KeyframeSelectorNotationOptions

  /**
   * Specify a pattern for keyframe names.
   *
   * >```scss
   * >@keyframes slide-right {}
   * >//          ^^^^^^^^^^^
   * >//        The pattern of this
   * >```
   *
   * ### Primary Options
   * `string | RegExp`
   *
   * @see [keyframes-name-pattern](https://stylelint.io/user-guide/rules/keyframes-name-pattern)
   */
  'keyframes-name-pattern': KeyframesNamePatternOptions

  /**
   * Specify a pattern for layer names.
   *
   * >```scss
   * >@layer foo {}
   * >//     ^^^
   * >//   This layer name
   * >```
   *
   * ### Primary Options
   * `string | RegExp`
   *
   * A string will be translated into a RegExp like so new RegExp(yourString) — so be sure to escape properly.
   *
   * Given the string: `"^[a-z][a-z0-9.-]*$"`
   *
   * @see [layer-name-pattern](https://stylelint.io/user-guide/rules/layer-name-pattern)
   */
  'layer-name-pattern': LayerNamePatternOptions

  /**
   * Disallow units for zero lengths.
   *
   * ```scss
   * a { top: 0px; }
   * //       ^^^
   * //  This zero and this type of length unit
   * ```
   *
   * _Lengths_ refer to distance measurements.
   * A length is a dimension, which is a number immediately followed by a unit identifier.
   * However, for zero lengths the unit identifier is optional.
   * The length units are: `em`, `ex`, `ch`, `vw`, `vh`, `cm`, `mm`, `in`, `pt`, `pc`, `px`, `rem`, `vmin`, and `vmax`.
   *
   * This rule ignores lengths within math functions (e.g. `calc`).
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignore`
   * - `ignoreFunctions`
   *
   * @see [length-zero-no-unit](https://stylelint.io/user-guide/rules/length-zero-no-unit)
   */
  'length-zero-no-unit': LengthZeroNoUnitOptions

  /**
   * Specify number or percentage notation for lightness.
   *
   * ```scss
   *   a { color: oklch(85% 0.17 88) }
   * //                 ^^^
   * //                 This notation
   * ```
   *
   * This rule supports `oklch`, `oklab`, `lch` and `lab` functions.
   *
   * ### Primary Options
   *
   * string: `"percentage"|"number"`
   *
   * - `"percentage"`: Lightness must always use the percentage notation.
   * - `"number"`: Lightness must always use the number notation.
   *
   * @see [lightness-notation](https://stylelint.io/user-guide/rules/lightness-notation)
   */
  'lightness-notation': LightnessNotationOptions

  /**
   * Limit the depth of nesting.
   *
   * ```scss
   * a { & > b { top: 0; } }
   * //  ^^^^^
   * //  This nesting
   * ```
   *
   * This rule works by checking rules' and at-rules' actual "nesting depth" against your specified max
   *
   * ### Primary Options
   *
   * `init`: Maximum nesting depth allowed.
   *
   * ### Optional Secondary Options
   * - `ignore`
   * - `ignoreAtRules`
   * - `ignorePseudoClasses`
   * - `ignoreRules`
   *
   * @see [max-nesting-depth](https://stylelint.io/user-guide/rules/max-nesting-depth)
   */
  'max-nesting-depth': MaxNestingDepthOptions

  /**
   * Specify a list of allowed media feature names.
   *
   * ```scss
   * \@media (min-width: 700px) {}
   * //       ^^^^^^^^^
   * //       This media feature name
   * ```
   *
   * ### Primary Options
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [media-feature-name-allowed-list](https://stylelint.io/user-guide/rules/media-feature-name-allowed-list)
   */
  'media-feature-name-allowed-list': MediaFeatureNameAllowedListOptions

  /**
   * Specify a list of disallowed media feature names.
   *
   * ```scss
   * \@media (min-width: 700px) {}
   * //       ^^^^^^^^^
   * //       This media feature name
   * ```
   *
   * ### Primary Options
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [media-feature-name-disallowed-list](https://stylelint.io/user-guide/rules/media-feature-name-disallowed-list)
   */
  'media-feature-name-disallowed-list': MediaFeatureNameDisallowedListOptions

  /**
   * Disallow unknown media feature names.
   *
   * ```scss
   * \@media (min-width: 700px) {}
   * //       ^^^^^^^^^
   * //       This media feature name
   * ```
   *
   * This rule considers media feature names defined in the CSS Specifications,
   * up to and including Editor's Drafts, to be known.
   *
   * This rule ignores vendor-prefixed media feature names.
   *
   * ### Primary Options
   * `true`
   *
   * ### Optional Secondary Options
   * - `ignoreMediaFeatureNames`
   *
   * @see [media-feature-name-no-unknown](https://stylelint.io/user-guide/rules/media-feature-name-no-unknown)
   */
  'media-feature-name-no-unknown': MediaFeatureNameNoUnknownOptions

  /**
   * Disallow vendor prefixes for media feature names.
   *
   * ```scss
   * \@media (-webkit-min-device-pixel-ratio: 1) {}
   * //       ^^^^^^^
   * //       this prefix
   * ```
   *
   * This rule ignores non-standard vendor-prefixed media feature names that aren't handled
   * by {@link https://github.com/postcss/autoprefixer Autoprefixer}.
   *
   * ### Primary Options
   * `true`
   *
   * @see [media-feature-name-no-vendor-prefix](https://stylelint.io/user-guide/rules/media-feature-name-no-vendor-prefix)
   */
  'media-feature-name-no-vendor-prefix': MediaFeatureNameNoVendorPrefixOptions

  /**
   * Specify a list of allowed name and unit pairs within media features.
   *
   * ```scss
   * @media (width: 50em) {}
   * //      ^^^^^    ^^
   * //   This media feature name and these units
   * ```
   *
   * ### Primary Options
   *
   * `object`: `{ "name": ["array", "of", "units"] | "unit" }`
   *
   * @see [media-feature-name-unit-allowed-list](https://stylelint.io/user-guide/rules/media-feature-name-unit-allowed-list)
   */
  'media-feature-name-unit-allowed-list': MediaFeatureNameUnitAllowedListOptions

  /**
   * Specify a list of allowed media feature name and value pairs.
   *
   * ```scss
   * \@media screen and (min-width: 768px) {}
   * //                  ^^^^^^^^^  ^^^
   * //       These features and values
   * ````
   *
   * ### Primary Options
   *
   * `object`: `{ "unprefixed-media-feature-name": ["array", "of", "values", "/regex/", /regex/]|"value"|"/regex/"|/regex/ }`
   *
   * If a media feature name is found in the object, only its allowed-listed values are allowed. If the media feature name is not included in the object, anything goes.
   *
   * If a name or value is surrounded with `/` (e.g. `"/width$/"`), it is interpreted as a regular expression. For example, `/width$/` will match `max-width` and `min-width`.
   *
   * @see [media-feature-name-value-allowed-list](https://stylelint.io/user-guide/rules/media-feature-name-value-allowed-list)
   */
  'media-feature-name-value-allowed-list': MediaFeatureNameValueAllowedListOptions

  /**
   * Disallow unknown values for media features.
   *
   * ```scss
   * \@media (color: red) {}
   * //      ^^^^^  ^^^
   * //   feature and value pairs like these
   * ```
   *
   * This rule considers values for media features defined within the CSS specifications to be known.
   *
   * This rule is only appropriate for CSS. You should not turn it on for CSS-like languages, such as Sass or Less, as they have their own syntaxes.
   *
   * @experimental This rule is experimental with some false negatives that we'll patch in minor releases.
   *
   * It sometimes overlaps with:
   * - [unit-no-unknown](https://stylelint.io/user-guide/rules/unit-no-unknown)
   *
   * If duplicate problems are flagged, you can turn off the corresponding rule.
   *
   * ### Primary Options
   * `trur`
   *
   * @see [media-feature-name-value-no-unknown](https://stylelint.io/user-guide/rules/media-feature-name-value-no-unknown)
   */
  'media-feature-name-value-no-unknown': MediaFeatureNameValueNoUnknownOptions

  /**
   * Specify context or prefix notation for media feature ranges.
   *
   * ```scss
   * \@media (width >= 600px) and (min-width: 600px) {}
   * //       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^
   * //       These media feature notations
   * ```
   *
   * Media features of the range type can be written using prefixes or the more modern context notation.
   *
   * Because `min-` and `max-` both equate to range comparisons that include the value,
   * they may be {@link https://drafts.csswg.org/mediaqueries/#mq-min-max limiting in certain situations}.
   *
   * ### Primary Options:
   * - `"context"`: Media feature ranges must always use context notation.
   * - `"prefix"`: Media feature ranges must always use prefix notation.
   *
   * @see [media-feature-range-notation](https://stylelint.io/user-guide/rules/media-feature-range-notation)
   */
  'media-feature-range-notation': MediaFeatureRangeNotationOptions

  /**
   * Disallow invalid media queries.
   *
   * ```scss
   * \@media not(min-width: 300px) {}
   * //      ^^^
   * //   This media query
   * ```
   *
   * Media queries must be grammatically valid according to the
   * {@link https://www.w3.org/TR/mediaqueries-5/ Media Queries Level 5} specification.
   *
   * This rule is only appropriate for CSS. You should not turn it on for CSS-like languages, such as Sass or Less, as they have their own syntaxes.
   *
   * It works well with other rules that validate feature names and values:
   * - [media-feature-name-no-unknown](https://stylelint.io/user-guide/rules/media-feature-name-no-unknown)
   * - [media-feature-name-value-no-unknown](https://stylelint.io/user-guide/rules/media-feature-name-value-no-unknown)
   *
   * ### Primary Options:
   * `true`
   *
   * @see [media-query-no-invalid](https://stylelint.io/user-guide/rules/media-query-no-invalid)
   */
  'media-query-no-invalid': MediaQueryNoInvalidOptions

  /**
   * Disallow invalid named grid areas.
   *
   * ```scss
   * a { grid-template-areas:
   *      "a a a"
   *      "b b b"; }
   * //  ^^^
   * //  This named grid area
   * ```
   *
   * For a named grid area to be valid, all strings must define:
   * - the same number of cell tokens
   * - at least one cell token
   *
   * And all named grid areas that spans multiple grid cells must form a single filled-in rectangle.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [named-grid-areas-no-invalid](https://stylelint.io/user-guide/rules/named-grid-areas-no-invalid)
   */
  'named-grid-areas-no-invalid': NamedGridAreasNoInvalidOptions

  /**
   * Disallow selectors of lower specificity from coming after overriding selectors of higher specificity.
   *
   * ```scss
   *   #container a { top: 10px; } a { top: 0; }
   * //^^^^^^^^^^^^                ^
   * //The order of these selectors represents descending specificity
   * ```
   *
   * Source order is important in CSS, and when two selectors have the same specificity,
   * the one that occurs last will take priority.
   * However, the situation is different when one of the selectors has a higher specificity.
   * In that case, source order does not matter:
   * the selector with higher specificity will win out even if it comes first.
   *
   * The clashes of these two mechanisms for prioritization, source order and specificity,
   * can cause some confusion when reading stylesheets.
   * If a selector with higher specificity comes before the selector it overrides,
   * we have to think harder to understand it, because it violates the source order
   * expectation. __Stylesheets are most legible when overriding selectors always come after
   * the selectors they override__. That way both mechanisms, source order and specificity,
   * work together nicely.
   *
   * This rule enforces that practice as best it can, reporting fewer errors than it should.
   * It cannot catch every actual overriding selector, but it can catch certain common mistakes.
   *
   * We recommend turning this rule off if you use a lot of nesting.
   *
   * ### Primary Options:
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignore`
   *
   * @see [no-descending-specificity](https://stylelint.io/user-guide/rules/no-descending-specificity)
   */
  'no-descending-specificity': NoDescendingSpecificityOptions

  /**
   * Disallow duplicate `@import` rules.
   *
   * ```scss
   *  \@import "a.css";
   *  \@import "a.css";
   * //^^^^^^^
   * //These are duplicates
   * ```
   *
   * ### Primary Options:
   * `true`
   *
   * @see [no-duplicate-at-import-rules](https://stylelint.io/user-guide/rules/no-duplicate-at-import-rules)
   */
  'no-duplicate-at-import-rules': NoDuplicateAtImportRulesOptions

  /**
   * Disallow duplicate selectors.
   *
   * ```scss
   *   .foo {} .bar {} .foo {}
   * //^^^^            ^^^^
   * // These duplicates
   * ```
   *
   * This rule checks for two types of duplication:
   * - Duplication of a single selector with a rule's selector list, e.g. `a, b, a {}`.
   * - Duplication of a selector list within a stylesheet, e.g. `a, b {} a, b {}`.
   *   Duplicates are found even if the selectors come in different orders or have
   *   different spacing, e.g. `a d, b > c {} b>c, a d {}`.
   *
   * The same selector is allowed to repeat in the following circumstances:
   * - It is used in different selector lists, e.g. `a {} a, b {}`.
   * - The duplicates are determined to originate in different stylesheets, e.g.
   *   you have concatenated or compiled files in a way that produces sourcemaps for
   *   PostCSS to read, e.g. postcss-import.
   * - The duplicates are in rules with different parent nodes,
   *   e.g. inside and outside of a media query.
   *
   * This rule resolves nested selectors. So `a b {} a { & b {} }` counts as a problem,
   * because the resolved selectors end up with a duplicate.
   *
   * ### Primary Options:
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `disallowInList`
   *
   * @see [no-duplicate-selectors](https://stylelint.io/user-guide/rules/no-duplicate-selectors)
   */
  'no-duplicate-selectors': NoDuplicateSelectorsOptions

  /**
   * Disallow empty sources.
   *
   * ```scss
   * ···\n\t
   * //^^^^^
   * // This empty source
   * ```
   *
   * A source containing only whitespace is considered empty.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [no-empty-source](https://stylelint.io/user-guide/rules/no-empty-source)
   *
   */
  'no-empty-source': NoEmptySourceOptions

  /**
   * Disallow invalid double-slash comments.
   *
   * ```css
   * a {
   *   // color: pink;
   *   ^^
   * }
   * ```
   *
   * Disallow double-slash comments `(//...)` are not supported by CSS and {@link https://stackoverflow.com/a/20192639/130652 could lead to unexpected results}.
   *
   * If you are using a preprocessor that allows `//` single-line comments
   * (e.g. Sass, Less, Stylus), this rule will not complain about those.
   * They are compiled into standard CSS comments by your preprocessor,
   * so Stylelint will consider them valid.
   * This rule only complains about the lesser-known method of using `//` to "comment out"
   * a single-line of code in regular CSS.
   * (If you didn't know this was possible, have a look at
   * {@link http://www.xanthir.com/b4U10 "Single Line Comments (//) in CSS"}).
   *
   * ### Primary options:
   * `true`
   *
   * @see [no-invalid-double-slash-comments](https://stylelint.io/user-guide/rules/no-invalid-double-slash-comments)
   */
  'no-invalid-double-slash-comments': NoInvalidDoubleSlashCommentsOptions

  /**
   * Disallow invalid position `@import` rules.
   *
   * ```scss
   *   a {}
   *  \@import 'foo.css';
   * //^^^^^^^
   * ```
   *
   * Any `@import` rules must precede all other valid at-rules and style rules in a stylesheet (ignoring `@charset` and `@layer`), or else the `@import` rule is invalid.
   *
   * ### Primary Options:
   * `true`
   *
   *
   * ### Optional Secondary Options:
   * - `ignoreAtRules`
   *
   * @see [no-invalid-position-at-import-rule](https://stylelint.io/user-guide/rules/no-invalid-position-at-import-rule)
   */
  'no-invalid-position-at-import-rule': NoInvalidPositionAtImportRuleOptions

  /**
   * Disallow irregular whitespaces.
   *
   * ```scss
   *   .firstClass .secondClass {}
   * //           ^
   * // Irregular whitespace. Selector would fail to match '.firstClass'
   * ```
   *
   * ### Primary Options:
   * `true`
   * @see [no-irregular-whitespace](https://stylelint.io/user-guide/rules/no-irregular-whitespace)
   */
  'no-irregular-whitespace': NoIrregularWhitespaceOptions

  /**
   * Disallow unknown animations.
   *
   * ```scss
   * a { animation-name: fancy-slide; }
   * //                  ^^^^^^^^^^^
   * a { animation: fancy-slide 2s linear; }
   * //             ^^^^^^^^^^^
   * ```
   *
   * This rule considers the identifiers of `@keyframes` rules defined within the same source to be known.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [no-unknown-animations](https://stylelint.io/user-guide/rules/no-unknown-animations)
   */
  'no-unknown-animations': NoUnknownAnimationsOptions

  /**
   * Disallow unknown custom media queries.
   *
   * ```scss
   * \@custom-media --sm (min-width: 40rem);
   * //             ^^^^
   * //    This custom media query name
   * \@media (--sm) {}
   * //       ^^^^
   * //       And this one
   * ```
   *
   * This rule considers custom media queries defined **within the same source** to be known.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [no-unknown-custom-media](https://stylelint.io/user-guide/rules/no-unknown-custom-media)
   */
  'no-unknown-custom-media': NoUnknownCustomMediaOptions

  /**
   * Disallow unknown custom properties.
   *
   * ```scss
   * a { color: var(--foo); }
   * //             ^^^^^
   * a { color: var(--foo, var(--bar)); }
   * //                        ^^^^^
   * ```
   *
   * This rule considers custom properties defined within the same source to be known.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [no-unknown-custom-properties](https://stylelint.io/user-guide/rules/no-unknown-custom-properties)
   */
  'no-unknown-custom-properties': NoUnknownCustomPropertiesOptions

  /**
   * Limit the number of decimal places allowed in numbers.
   *
   * ```scss
   * a { top: 3.245634px; }
   * //         ^^^^^^
   * //       This decimal place
   * ```
   *
   * ### Primary Options:
   *
   * `int`: Maximum number of decimal places allowed.
   *
   * ### Optional Secondary Options:
   * - `ignoreProperties`
   * - `ignoreUnits`
   * - `insideFunctions`
   *
   * @see [number-max-precision](https://stylelint.io/user-guide/rules/number-max-precision)
   */
  'number-max-precision': NumberMaxPrecisionOptions

  /**
   * Specify a list of allowed properties.
   *
   * ```scss
   * a { display: block; }
   * //  ^^^^^^^
   * ```
   *
   * This rule ignores variables (`$sass`, `@less`, `--custom-property`).
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [property-allowed-list](https://stylelint.io/user-guide/rules/property-allowed-list)
   */
  'property-allowed-list': PropertyAllowedListOptions

  /**
   * Specify a list of disallowed properties.
   *
   * ```scss
   * a { text-rendering: optimizeLegibility; }
   * //  ^^^^^^^^^^^^^^
   * ```
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [property-disallowed-list](https://stylelint.io/user-guide/rules/property-disallowed-list)
   */
  'property-disallowed-list': PropertyDisallowedListOptions

  /**
   * Disallow unknown properties.
   *
   * ```scss
   * a { height: 100%; }
   * //  ^^^^^^
   * ```
   *
   * This rule considers properties defined in the {@link https://github.com/betit/known-css-properties#source CSS Specifications and browser specific properties} to be known.
   *
   * This rule ignores:
   * - variables (`$sass`, `@less`, `--custom-property`)
   * - vendor-prefixed properties (e.g., `-moz-align-self`, `-webkit-align-self`)
   *
   * ### Primary Options:
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignoreProperties`
   * - `ignoreSelectors`
   * - `ignoreAtRules`
   * - `checkPrefixed`
   *
   * @see [property-no-unknown](https://stylelint.io/user-guide/rules/property-no-unknown)
   */
  'property-no-unknown': PropertyNoUnknownOptions

  /**
   * Disallow vendor prefixes for properties.
   *
   * ```scss
   * a { -webkit-transform: scale(1); }
   * //  ^^^^^^^^
   * ```
   *
   * This rule ignores non-standard vendor-prefixed properties that aren't handled by {@link https://github.com/postcss/autoprefixer Autoprefixer}.
   *
   * ### Primary Options:
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignoreProperties`
   *
   * @see [property-no-vendor-prefix](https://stylelint.io/user-guide/rules/property-no-vendor-prefix)
   */
  'property-no-vendor-prefix': PropertyNoVendorPrefixOptions

  /**
   * Require or disallow an empty line before rules.
   *
   * ```scss
   * a {}
   *       // this line
   * b {}
   * ```
   *
   * This rule ignores rules that are the very first node in a source.
   *
   * ### Primary Options:
   * - `"always"`: There must always be an empty line before rules.
   * - `"never"`: There must never be an empty line before rules.
   * - `"always-multi-line"`: There must always be an empty line before multi-line rules.
   * - `"never-multi-line"`: There must never be an empty line before multi-line rules.
   *
   * ### Optional Secondary Options:
   * - `except`
   * - `ignore`
   *
   * @see [rule-empty-line-before](https://stylelint.io/user-guide/rules/rule-empty-line-before)
   */
  'rule-empty-line-before': RuleEmptyLineBeforeOptions

  /**
   * Specify a list of disallowed properties for selectors within rules.
   *
   * ```scss
   *   a { color: red; }
   * //^   ^^^^^
   * //Selector and property name
   * ```
   *
   * ### Primary Options:
   *
   * `Record<string, string | RegExp | (string | RegExp)[]>`
   *
   * ```json
   * {
   *   "a": ["color", "/margin/"],
   *   "/foo/": "/size/"
   * }
   * ```
   *
   * ### Optional Secondary Options:
   *
   * - `ignore`
   *
   * @see [rule-selector-property-disallowed-list](https://stylelint.io/user-guide/rules/rule-selector-property-disallowed-list)
   */
  'rule-selector-property-disallowed-list': RuleSelectorPropertyDisallowedListOptions

  /**
   * Disallow unmatchable An+B selectors.
   *
   * ```scss
   *   a:nth-child(0n+0) {}
   * //            ^^^^
   * ```
   *
   * {@link https://www.w3.org/TR/css-syntax-3/#anb-microsyntax An+B selectors} are one-indexed. Selectors that always evaluate to 0 will not match any elements.
   *
   * ### Primary Options:
   * `true`
   *
   * @see [selector-anb-no-unmatchable](https://stylelint.io/user-guide/rules/selector-anb-no-unmatchable)
   */
  'selector-anb-no-unmatchable': SectorAnbNoUnmatchableOptions

  /**
   * Specify a list of disallowed attribute names.
   *
   * ```scss
   *   [class~="foo"] {}
   * // ^^^^^
   * ```
   *
   * ### Primary Options:
   * `true`
   *
   * @see [selector-attribute-name-disallowed-list](https://stylelint.io/user-guide/rules/selector-attribute-name-disallowed-list)
   */
  'selector-attribute-name-disallowed-list': SelectorAttributeNameDisallowedListOptions

  /**
   * Specify a list of allowed attribute operators.
   *
   * ```scss
   *   [target="_blank"] {}
   * //       ^
   * ```
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * @see [selector-attribute-operator-allowed-list](https://stylelint.io/user-guide/rules/selector-attribute-operator-allowed-list)
   */
  'selector-attribute-operator-allowed-list': SelectorAttributeOperatorAllowedListOptions

  /**
   * Specify a list of disallowed attribute operators.
   *
   * ```scss
   *   [target="_blank"] {}
   * //       ^
   * ```
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * @see [selector-attribute-operator-disallowed-list](https://stylelint.io/user-guide/rules/selector-attribute-operator-disallowed-list)
   */
  'selector-attribute-operator-disallowed-list': SelectorAttributeOperatorDisallowedListOptions

  /**
   * Require or disallow quotes for attribute values.
   *
   * ```scss
   *   [target="_blank"] {}
   * //        ^      ^
   * ```
   *
   * ### Primary Options:
   * - `always`: Attribute values must always be quoted.
   * - `never`: Attribute values must never be quoted.
   *
   * @see [selector-attribute-quotes](https://stylelint.io/user-guide/rules/selector-attribute-quotes)
   */
  'selector-attribute-quotes': SelectorAttributeQuotesOptions

  /**
   * Specify a pattern for class selectors.
   *
   * ```scss
   *    .foo, #bar.baz span, #hoo[disabled] { color: pink; }
   * // ^         ^
   * ```
   *
   * This rule ignores non-outputting Less mixin definitions and called Less mixins.
   *
   * Escaped selectors (e.g. `.u-size-11\/12\@sm`) are parsed as escaped twice (e.g. `.u-size-11\\/12\\@sm`). Your RegExp should account for that.
   *
   * ### Primary Options:
   *
   * `string | RegExp`
   *
   * ### Optional Secondary Options:
   * - `resolveNestedSelectors`
   *
   * @see [selector-class-pattern](https://stylelint.io/user-guide/rules/selector-class-pattern)
   */
  'selector-class-pattern': SelectorClassPatternOptions

  /**
   * Specify a list of allowed combinators.
   *
   * ```scss
   *   a + b {}
   * //  ^
   * ```
   *
   * This rule normalizes the whitespace descendant combinator to be a single space.
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * This rule ignores {@link https://www.w3.org/TR/selectors4/#idref-combinators reference combinators} e.g. `/for/`.
   *
   * @see [selector-combinator-allowed-list](https://stylelint.io/user-guide/rules/selector-combinator-allowed-list)
   */
  'selector-combinator-allowed-list': SelectorCombinatorAllowedListOptions

  /**
   * Specify a list of disallowed combinators.
   *
   * ```scss
   *   a + b {}
   * //  ^
   * ```
   *
   * This rule normalizes the whitespace descendant combinator to be a single space.
   *
   * This rule ignores {@link https://www.w3.org/TR/selectors4/#idref-combinators reference combinators} e.g. `/for/`.
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * @see [selector-combinator-disallowed-list](https://stylelint.io/user-guide/rules/selector-combinator-disallowed-list)
   */
  'selector-combinator-disallowed-list': SelectorCombinatorDisallowedListOptions

  /**
   * Specify a list of disallowed selectors.
   *
   * ```scss
   *    .foo > .bar
   * // ^
   * ```
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * ### Optional Secondary Options:
   * - `splitList`
   * - `ignore`
   *
   * @see [selector-disallowed-list](https://stylelint.io/user-guide/rules/selector-disallowed-list)
   */
  'selector-disallowed-list': SelectorDisallowedListOptions

  /**
   * Specify a pattern for ID selectors.
   *
   * ```scss
   *    .foo, #bar.baz a, #hoo[disabled] { color: pink; }
   * //       ^^^^        ^^^^
   * ```
   *
   * ### Primary Options:
   *
   * `string | RegExp`
   *
   * @see [selector-id-pattern](https://stylelint.io/user-guide/rules/selector-id-pattern)
   */
  'selector-id-pattern': SelectorIdPatternOptions

  /**
   * Limit the number of attribute selectors in a selector.
   *
   * ```scss
   *    [rel="external"] {}
   * // ^^^^^^^^^^^^^^^^
   * ```
   *
   * This rule resolves nested selectors before counting the number of attribute selectors.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The `:not()` pseudo-class is also evaluated separately.
   * The rule processes the argument as if it were an independent selector,
   * and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum attribute selectors allowed.
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreAttributes`
   *
   * @see [selector-max-attribute](https://stylelint.io/user-guide/rules/selector-max-attribute)
   */
  'selector-max-attribute': SelectorMaxAttributeOptions

  /**
   * Limit the number of classes in a selector.
   *
   * ```scss
   *    div .foo.bar[data-val] > a.baz {}
   * //     ^   ^                 ^
   * //     1   2                 3
   * ```
   *
   * This rule resolves nested selectors before counting the number of classes in a selector.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The `:not()` pseudo-class is also evaluated separately.
   * The rule processes the argument as if it were an independent selector,
   * and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum classes allowed.
   *
   * @see [selector-max-class](https://stylelint.io/user-guide/rules/selector-max-class)
   */
  'selector-max-class': SelectorMaxClassOptions

  /**
   * Limit the number of combinators in a selector.
   *
   * ```scss
   *    a > b + c ~ d e { color: pink; }
   * //   ^   ^   ^  ^
   * ```
   *
   * This rule resolves nested selectors before counting the number of combinators selectors.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * ### Primary Options:
   *
   * `int`: Maximum combinators selectors allowed.
   *
   * @see [selector-max-combinators](https://stylelint.io/user-guide/rules/selector-max-combinators)
   */
  'selector-max-combinators': SelectorMaxCombinatorsOptions

  /**
   * Limit the number of compound selectors in a selector.
   *
   * ```scss
   *    div .bar[data-val] > a.baz + .boom > #lorem {}
   * // ^   ^                ^^      ^^      ^^
   * // 1   2                 3       4       5
   * ```
   *
   * A {@link https://www.w3.org/TR/selectors4/#compound compound selector} is
   * a chain of one or more simple (tag, class, ID, universal, attribute) selectors.
   * If there is more than one compound selector in a complete selector,
   * they will be separated by combinators (e.g. ` `, `+`, `>`).
   * One reason why you might want to limit the number of compound selectors is described
   * in the {@link http://smacss.com/book/applicability SMACSS book}.
   *
   * This rule resolves nested selectors before counting the depth of a selector.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * `:not()` is considered one compound selector irrespective to the complexity of the selector inside it.
   * The rule does process that inner selector, but does so separately, independent of the main selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum compound selectors allowed.
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreSelectors`: Ignore some compound selectors. This may be useful for deep selectors like Vue's `::v-deep` or Angular's `::ng-deep` that behave more like combinators than compound selectors.
   *
   * @see [selector-max-compound-selectors](https://stylelint.io/user-guide/rules/selector-max-compound-selectors)
   */
  'selector-max-compound-selectors': SelectorMaxCompoundSelectorsOptions

  /**
   * Limit the number of ID selectors in a selector.
   *
   * ```scss
   *    #foo {}
   * // ^^^
   * ```
   *
   * This rule resolves nested selectors before counting the number of ID selectors.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The `:not()` pseudo-class is also evaluated separately.
   * The rule processes the argument as if it were an independent selector,
   * and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum universal selectors allowed.
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreContextFunctionalPseudoClasses`
   *
   * @see [selector-max-id](https://stylelint.io/user-guide/rules/selector-max-id)
   */
  'selector-max-id': SelectorMaxIdOptions

  /**
   * Limit the number of pseudo-classes in a selector.
   *
   * ```scss
   *    .foo .bar:first-child:hover {}
   * //          ^           ^
   * //          1           2
   * ```
   *
   * This rule resolves nested selectors before counting the number of pseudo-classes in a selector.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The content of the `:not()` pseudo-class is also evaluated separately. The rule processes the argument as if it were an independent selector, and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum pseudo-classes allowed.
   *
   * @see [selector-max-pseudo-class](https://stylelint.io/user-guide/rules/selector-max-pseudo-class)
   */
  'selector-max-pseudo-class': SelectorMaxPseudoClassOptions

  /**
   * Limit the specificity of selectors.
   *
   * ```scss
   *    .foo, #bar.baz span, #hoo { color: pink; }
   * // ^     ^              ^
   * ```
   *
   * Visit the {@link https://specificity.keegan.st/ Specificity Calculator}
   * for visual representation of selector specificity.
   *
   * This rule ignores selectors with variable interpolation (`#{$var}`, `@{var}`, `$(var)`).
   *
   * This rule resolves nested selectors before counting the specificity of a selector.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * ### PrimaryOption
   * `string`: Maximum specificity allowed.
   *
   * Format is "id,class,type", as laid out in the {@link https://drafts.csswg.org/selectors/#specificity-rules W3C selector spec}.
   *
   * @see [selector-max-specificity](https://stylelint.io/user-guide/rules/selector-max-specificity)
   */
  'selector-max-specificity': SelectorMaxSpecificityOptions

  /**
   * Limit the number of type selectors in a selector.
   *
   * ```scss
   *    a {}
   * // ^
   * ```
   *
   * This rule resolves nested selectors before counting the number of type selectors.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The `:not()` pseudo-class is also evaluated separately. The rule processes the argument as if it were an independent selector, and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum type selectors allowed.
   *
   * ### Optional Secondary Options:
   *
   * - `ignore`
   * - `ignoreTypes`
   *
   * @see [selector-max-type](https://stylelint.io/user-guide/rules/selector-max-type)
   */
  'selector-max-type': SelectorMaxTypeOptions

  /**
   * Limit the number of universal selectors in a selector.
   *
   * ```scss
   *    {}
   * // ^
   * ```
   *
   * This rule resolves nested selectors before counting the number of universal selectors.
   * Each selector in a {@link https://www.w3.org/TR/selectors4/#selector-list selector list} is evaluated separately.
   *
   * The logical combinations pseudo-class (e.g. `:not`, `:has`) is also evaluated separately. The rule processes the argument as if it were an independent selector, and the result does not count toward the total for the entire selector.
   *
   * ### Primary Options:
   *
   * `int`: Maximum universal selectors allowed.
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreAfterCombinators`
   *
   * @see [selector-max-universal](https://stylelint.io/user-guide/rules/selector-max-universal)
   */
  'selector-max-universal': SelectorMaxUniversalOptions

  /**
   * Specify a pattern for the selectors of rules nested within rules.
   *
   * ```scss
   *    a {
   *      color: orange;
   *      &:hover { color: pink; }
   * //   ^^^^^^^
   *    }
   * ```
   *
   * Non-standard selectors (e.g. selectors with Sass or Less interpolation) and selectors of rules nested within at-rules are ignored.
   *
   * ### Primary Options:
   *
   * `string | RegExp`
   *
   * ### Optional Secondary Options:
   *
   * - `splitList`
   *
   * @see [selector-nested-pattern](https://stylelint.io/user-guide/rules/selector-nested-pattern)
   */
  'selector-nested-pattern': SelectorNestedPatternOptions

  /**
   * Disallow qualifying a selector by type.
   *
   * ```scss
   *     a.foo {}
   * //  ^^^^
   * // This type selector is qualifying the class
   * ```
   *
   * A type selector is "qualifying" when it is compounded with (chained to) another selector
   * (e.g. `a.foo`, `a#foo`). This rule does not regulate type selectors that are
   * combined with other selectors via a combinator (e.g. `a > .foo`, `a #foo`).
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignore`
   *
   * @see [selector-no-qualifying-type](https://stylelint.io/user-guide/rules/selector-no-qualifying-type)
   */
  'selector-no-qualifying-type': SelectorNoQualifyingTypeOptions

  /**
   * Disallow vendor prefixes for selectors.
   *
   * ```scss
   *    input::-moz-placeholder {}
   * //        ^^^^^
   * ```
   *
   * This rule ignores non-standard vendor-prefixed selectors that aren't handled by
   * {@link https://github.com/postcss/autoprefixer Autoprefixer}.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreSelectors`
   *
   * @see [selector-no-vendor-prefix](https://stylelint.io/user-guide/rules/selector-no-vendor-prefix)
   */
  'selector-no-vendor-prefix': SelectorNoVendorPrefixOptions

  /**
   * Specify simple or complex notation for `:not()` pseudo-class selectors.
   *
   * ```scss
   *    a:not(.foo, .bar) {}
   * //   ^^^
   * ```
   *
   * In Selectors Level 3, only a single simple selector was allowed as the argument to `:not()`, whereas Selectors Level 4 allows a selector list.
   *
   * ### Primary Options:
   * - `"complex"`: to author modern Selectors Level 4 CSS
   * - `"simple"`: for backwards compatibility with older browsers
   *
   * @see [selector-not-notation](https://stylelint.io/user-guide/rules/selector-not-notation)
   */
  'selector-not-notation': SelectorNotNotationOptions

  /**
   * Specify a list of allowed pseudo-class selectors.
   *
   * ```scss
   *    a:hover {}
   * //   ^^^^^
   * ```
   *
   * This rule ignores selectors that use variable interpolation e.g. `:#{$variable} {}`.
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [selector-pseudo-class-allowed-list](https://stylelint.io/user-guide/rules/selector-pseudo-class-allowed-list)
   */
  'selector-pseudo-class-allowed-list': SelectorPseudoClassAllowedListOptions

  /**
   * Specify a list of disallowed pseudo-class selectors.
   *
   * ```scss
   *    a:hover {}
   * //   ^^^^^
   * ```
   *
   * This rule ignores selectors that use variable interpolation e.g. `:#{$variable} {}`.
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [selector-pseudo-class-disallowed-list](https://stylelint.io/user-guide/rules/selector-pseudo-class-disallowed-list)
   */
  'selector-pseudo-class-disallowed-list': SelectorPseudoClassDisallowedListOptions

  /**
   * Disallow unknown pseudo-class selectors.
   *
   * ```scss
   *    a:hover {}
   * //   ^^^^^
   * ```
   *
   * This rule considers pseudo-class selectors defined in the CSS Specifications,
   * up to and including Editor's Drafts, to be known.
   *
   * This rule ignores vendor-prefixed pseudo-class selectors.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `ignorePseudoClasses`
   *
   * @see [selector-pseudo-class-no-unknown](https://stylelint.io/user-guide/rules/selector-pseudo-class-no-unknown)
   */
  'selector-pseudo-class-no-unknown': SelectorPseudoClassNoUnknownOptions

  /**
   * Specify a list of allowed pseudo-element selectors.
   *
   * ```scss
   *    a::before {}
   * //    ^^^^^^
   * ```
   *
   * This rule ignores:
   * - CSS2 pseudo-elements i.e. those prefixed with a single colon
   * - selectors that use variable interpolation e.g. `::#{$variable} {}`
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [selector-pseudo-element-allowed-list](https://stylelint.io/user-guide/rules/selector-pseudo-element-allowed-list)
   */
  'selector-pseudo-element-allowed-list': SelectorPseudoElementAllowedListOptions

  /**
   * Specify a list of disallowed pseudo-element selectors.
   *
   * ```scss
   *     a::before {}
   * //     ^^^^^^
   * ```
   *
   * This rule ignores:
   * - CSS2 pseudo-elements i.e. those prefixed with a single colon
   * - selectors that use variable interpolation e.g. `::#{$variable} {}`
   *
   * ### Primary Options:
   *
   * `string | RegExp | (string | RegExp)[]`
   *
   * @see [selector-pseudo-element-disallowed-list](https://stylelint.io/user-guide/rules/selector-pseudo-element-disallowed-list)
   */
  'selector-pseudo-element-disallowed-list': SelectorPseudoElementDisallowedListOptions

  /**
   * Specify single or double colon notation for applicable pseudo-element selectors.
   *
   * ```scss
   *     a::before {}
   * //   ^^
   * ```
   *
   * The `::` notation was chosen for pseudo-elements to establish a discrimination between
   * pseudo-classes (which subclass existing elements) and pseudo-elements
   * (which are elements not represented in the document tree).
   *
   * However, for compatibility with existing style sheets,
   * user agents also accept the previous one-colon notation for pseudo-elements introduced
   * in CSS levels 1 and 2 (namely, `:first-line`, `:first-letter`, `:before` and `:after`).
   *
   * ### Primary Options:
   * - `"single"`: Applicable pseudo-elements must always use the single colon notation.
   * - `"double"`: Applicable pseudo-elements must always use the double colon notation.
   *
   * @see [selector-pseudo-element-colon-notation](https://stylelint.io/user-guide/rules/selector-pseudo-element-colon-notation)
   */
  'selector-pseudo-element-colon-notation': SelectorPseudoElementColonNotationOptions

  /**
   * Disallow unknown pseudo-element selectors.
   *
   * ```scss
   *    a::before {}
   * //    ^^^^^^
   * ```
   *
   * This rule considers pseudo-element selectors defined in the CSS Specifications,
   * up to and including Editor's Drafts, to be known.
   *
   * This rule ignores vendor-prefixed pseudo-element selectors.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `ignorePseudoElements`
   *
   * @see [selector-pseudo-element-no-unknown](https://stylelint.io/user-guide/rules/selector-pseudo-element-no-unknown)
   */
  'selector-pseudo-element-no-unknown': SelectorPseudoElementNoUnknownOptions

  /**
   * Specify lowercase or uppercase for type selectors.
   *
   * ```scss
   *    a {}
   * // ^
   * ```
   *
   * ### Primary Options:
   * - `"lower"`
   * - `"upper"`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreTypes`
   *
   * @see [selector-type-case](https://stylelint.io/user-guide/rules/selector-type-case)
   */
  'selector-type-case': SelectorTypeCaseOptions

  /**
   * Disallow unknown type selectors.
   *
   * ```scss
   *    unknown {}
   * // ^^^^^^^
   * ```
   *
   * This rule considers tags defined in the HTML, SVG, and MathML specifications to be known.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   * - `ignore`
   * - `ignoreNamespaces`
   * - `ignoreTypes`
   *
   * @see [selector-type-no-unknown](https://stylelint.io/user-guide/rules/selector-type-no-unknown)
   */
  'selector-type-no-unknown': SelectorTypeNoUnknownOptions

  /**
   * Disallow redundant values within shorthand properties.
   *
   * ```scss
   *    a { margin: 1px 1px 1px 1px; }
   * //             ^   ^   ^   ^
   * ```
   *
   * You can use {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties shorthand properties} to set multiple values at once.
   * For example, you can use the margin property to set the `margin-top`, `margin-right`,
   * `margin-bottom`, and `margin-left` properties at once.
   *
   * For some shorthand properties, e.g. those related to the {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties#edges_of_a_box edges of a box},
   * you can safely omitted some values.
   *
   * This rule checks the following shorthand properties:
   * `margin`, `padding`, `border-color`, `border-radius`,
   * `border-style`, `border-width`, `grid-gap`, `inset`
   *
   * ### Primary Options:
   *
   * `true`
   *
   * @see [shorthand-property-no-redundant-values](https://stylelint.io/user-guide/rules/shorthand-property-no-redundant-values)
   */
  'shorthand-property-no-redundant-values': ShorthandPropertyNoRedundantValuesOptions

  /**
   * Disallow invalid newlines within strings.
   *
   * ```scss
   *    a {
   *      content: "first  // The newline here
   *        second";
   *    }
   * ```
   *
   * {@link https://www.w3.org/TR/CSS2/syndata.html#strings The spec}
   * says this: "A string cannot directly contain a newline.
   * To include a newline in a string, use an escape representing the line feed character in
   * ISO-10646 (U+000A), such as '\A' or '\00000a'."
   * And also: "It is possible to break strings over several lines,
   * for aesthetic or other reasons, but in such a case the newline itself has to be escaped with
   * a backslash (\)."
   *
   * ### Primary Options:
   *
   * `true`
   *
   * @see [string-no-newline](https://stylelint.io/user-guide/rules/string-no-newline)
   */
  'string-no-newline': StringNoNewlineOptions

  /**
   * Disallow invalid syntax strings.
   *
   * ```scss
   * \@property --foo {
   *   syntax: "<color>";
   * //        ^
   * //        Syntax strings like this
   * }
   * ```
   *
   * Syntax strings are used for the `syntax` descriptor value of the `@property` at-rule. This rule checks their grammar and flags unsupported type names.
   *
   * You can check [§5.1 “Supported Names” of the CSS Properties & Values API](https://drafts.css-houdini.org/css-properties-values-api/#supported-names) for a list of valid syntax component names.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * @see [syntax-string-no-invalid](https://stylelint.io/user-guide/rules/syntax-string-no-invalid)
   */
  'syntax-string-no-invalid': SyntaxStringNoInvalidOptions

  /**
   * Limit the minimum number of milliseconds for time values.
   *
   * ```scss
   *    a { animation: slip-n-slide 150ms linear; }
   * //                             ^^^^^
   * ```
   *
   * This rule checks positive numbers in `transition-duration`, `transition-delay`,
   * `animation-duration`, `animation-delay`, and those times as they manifest
   * in the `transition` and `animation` shorthands.
   *
   * ### Primary Options:
   *
   * `int`: Minimum number of milliseconds for time values.
   *
   * ### Optional Secondary Options:
   *
   * - `ignore`
   *
   * @see [time-min-milliseconds](https://stylelint.io/user-guide/rules/time-min-milliseconds)
   */
  'time-min-milliseconds': TimeMinMillisecondsOptions

  /**
   * Specify a list of allowed units.
   *
   * ```scss
   *     a { width: 100px; }
   * //                ^^
   * ```
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreProperties`
   * - `ignoreFunctions`
   *
   * @see [unit-allowed-list](https://stylelint.io/user-guide/rules/unit-allowed-list)
   */
  'unit-allowed-list': UnitAllowedListOptions

  /**
   * unit-disallowed-list
   *
   * ```scss
   *    a { width: 100px; }
   * //               ^^
   * ```
   *
   * ### Primary Options:
   *
   * `string | string[]`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreProperties`
   * - `ignoreMediaFeatureNames`
   * - `ignoreFunctions`
   *
   * @see [unit-disallowed-list](https://stylelint.io/user-guide/rules/unit-disallowed-list)
   */
  'unit-disallowed-list': UnitDisallowedListOptions

  /**
   * Disallow unknown units.
   *
   * ```scss
   *     a { width: 100pixels; }
   * //                ^^^^^^
   * ```
   *
   * This rule considers units defined in the CSS Specifications, up to and including Editor's Drafts, to be known.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreUnits`
   * - `ignoreFunctions`
   *
   * @see [unit-no-unknown](https://stylelint.io/user-guide/rules/unit-no-unknown)
   */
  'unit-no-unknown': UnitNoUnknownOptions

  /**
   * Specify lowercase or uppercase for keywords values.
   *
   * ```scss
   *     a { display: block; }
   * //               ^^^^^
   * ```
   *
   * This rule ignores {@link https://developer.mozilla.org/en/docs/Web/CSS/custom-ident \<custom-idents\>} of known properties.
   * Keyword values which are paired with non-properties (e.g. `$vars` and custom properties),
   * and do not conform to the primary option, can be ignored using the
   * `ignoreKeywords: []` secondary option.
   *
   * ### Primary Options:
   *
   * - `"lower"`
   * - `"upper"`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreKeywords`
   * - `ignoreProperties`
   * - `ignoreFunctions`
   * - `camelCaseSvgKeywords`
   *
   * @see [value-keyword-case](https://stylelint.io/user-guide/rules/value-keyword-case)
   */
  'value-keyword-case': ValueKeywordCaseOptions

  /**
   * Disallow vendor prefixes for values.
   *
   * ```scss
   *     a { display: -webkit-flex; }
   * //               ^^^^^^^
   * ```
   *
   * This rule ignores non-standard vendor-prefixed values that aren't handled by
   * {@link https://github.com/postcss/autoprefixer Autoprefixer}.
   *
   * ### Primary Options:
   *
   * `true`
   *
   * ### Optional Secondary Options:
   *
   * - `ignoreValues`
   *
   * @see [value-no-vendor-prefix](https://stylelint.io/user-guide/rules/value-no-vendor-prefix)
   */
  'value-no-vendor-prefix': ValueNoVendorPrefixOptions
}

/**
 * This is a special exported interface for other packages to declare
 * additional types that should bail out for stylelint rules. For example
 * `stylelint-scss` can declare it like so in its `d.ts`:
 *
 * ```ts
 * import type { RuleConfig } from 'stylelint-define-config';
 * declare module 'stylelint-define-config' {
 *   export interface CustomRuleOptions {
 *     'scss/at-else-closing-brace-newline-after': RuleConfig<
 *        "always-last-in-chain",
 *        { disableFix?: boolean }
 *      >
 *
 *     // ... more Rules
 *   }
 * }
 * ```
 */
interface CustomRuleOptions {}

type CustomRules = {
  [TRuleName in keyof CustomRuleOptions]: CustomRuleOptions[TRuleName]
}

/**
 * Rules determine what the linter looks for and complains about.
 * There are {@link https://stylelint.io/user-guide/rules over 100 rules} built into Stylelint. No rules are turned on by default.
 */
interface Rules extends
  StyleLintRules,
  CustomRules,
  Record<string, RuleConfig<any>> {}

/**
 * This is a special exported interface for other packages to declare
 * additional types that should bail out for stylelint postcss custom syntax. For example
 * `stylelint-scss` can declare it like so in its `d.ts`:
 *
 * ```ts
 * declare module 'stylelint-define-config' {
 *   export interface CustomSyntax {
 *     'postcss-scss': void;
 *
 *     // ... more syntax
 *   }
 * }
 * ```
 */
interface CustomSyntax {}

type KnownCustomSyntax = LiteralUnion<
  | 'postcss-angular'
  | 'postcss-html'
  | 'postcss-less'
  | 'postcss-linaria'
  | 'postcss-lit'
  | 'postcss-markdown'
  | 'postcss-sass'
  | 'postcss-scss'
  | 'postcss-styled-components'
  | 'postcss-styled-syntax'
  | keyof CustomSyntax
>

/**
 * This is a special exported interface for other packages to declare
 * additional types that should bail out for stylelint extends. For example
 * `stylelint-scss` can declare it like so in its `d.ts`:
 *
 * ```ts
 * declare module 'stylelint-define-config' {
 *   export interface CustomExtends {
 *     'stylelint-config-standard-scss': void;
 *
 *     // ... more extends
 *   }
 * }
 * ```
 */
interface CustomExtends {}

type KnownExtends = LiteralUnion<
  | 'stylelint-config-standard'
  | 'stylelint-config-standard-scss'
  | 'stylelint-config-prettier'
  | 'stylelint-config-prettier-scss'
  | 'stylelint-config-recommended-vue'
  | keyof CustomExtends
>

interface LanguageOptions {
  syntax?: {
    atRules?: Record<
      string,
      {
        comment?: string
        prelude?: string
        descriptors?: Record<string, string>
      }
    >
    cssWideKeywords?: string[]
    properties?: Record<string, string>
    types?: Record<string, string>
  }
}

/**
 * This is a special exported interface for other packages to declare
 * additional plugins that should bail out for stylelint plugins. For example
 * `'stylelint-scss'` can declare it like so in its `d.ts`:
 *
 * ```ts
 * declare module 'stylelint-define-config' {
 *   export interface CustomPlugins {
 *     'stylelint-scss': void;
 *   }
 * }
 * ```
 */
interface CustomPlugins {}

type KnownPlugins = LiteralUnion<
  | 'stylelint-order' | 'stylelint-scss' | '@stylistic/stylelint-plugin' | 'stylelint-stylus'
  | 'stylelint-suitcss' | 'stylelint-react-native'
  | keyof CustomPlugins
>

type Plugins = KnownPlugins | Plugin | (KnownPlugins | Plugin)[]

interface PluginFunctions {
  [pluginName: string]: Rule
}

type Extends = KnownExtends | StylelintConfig

type DisableSettings = ConfigRuleSettings<boolean, DisableOptions>

/**
 * specify what subset of files to apply a configuration to.
 */
interface Override extends Omit<StylelintConfig, 'overrides'> {
  /**
   * Which is an array of glob patterns that specify which files
   * the configuration should be applied to
   */
  files: string | string[]

  name?: string
}

/**
 * Stylelint configuration
 * @see [Stylelint configuration](https://stylelint.io/user-guide/configure)
 */
interface StylelintConfig {
  /**
   * Specify the formatter to format your results.
   *
   * @see [Configure formatter](https://stylelint.io/user-guide/configure#formatter)
   */
  formatter?: Formatter | LiteralUnion<FormatterType>

  /**
   * Automatically fix, where possible, problems reported by rules.
   *
   * Options are:
   * - "lax" (default) - uses `postcss-safe-parser` to fix as much as possible, even when there are syntax errors
   * - "strict" - uses PostCSS Parser and only fixes problems when there are no syntax errors
   *
   * @see [Configure fix](https://stylelint.io/user-guide/configure#fix)
   */
  fix?: boolean | 'lax' | 'strict'

  /**
   * Store the results of processed files so that Stylelint only operates on the changed ones.
   *
   * @see [Configure cache](https://stylelint.io/user-guide/configure#cache)
   *
   */
  cache?: boolean

  /**
   * If `true`, Only register problems for rules with an "error"-level
   * severity (ignore "warning"-level).
   */
  quiet?: boolean

  /**
   * Stylelint does not throw an error when the glob pattern matches no files.
   *
   * @see [Configure allowEmptyInput](https://stylelint.io/user-guide/configure#allowemptyinput)
   */
  allowEmptyInput?: boolean

  /**
   * You can provide a glob or array of globs to ignore specific files.
   *
   * Stylelint ignores the `node_modules` directory by default.
   * However, this is overridden if ignoreFiles is set.
   *
   * If the globs are absolute paths, they are used as is.
   * If they are relative, they are analyzed relative to
   * - `configBasedir`, if it's provided;
   * - the config's filepath, if the config is a file that Stylelint found and loaded;
   * - or `process.cwd()`.
   *
   * @see [Configure ignoreFiles](https://stylelint.io/user-guide/configure#ignorefiles)
   */
  ignoreFiles?: string | string[]

  /**
   * Pattern of files to ignore (in addition to those in `.stylelintignore` ).
   * @see [Configure ignorePatterns](https://stylelint.io/user-guide/configure#ignorefiles)
   * @example
   * ```json
   * {
   *   "ignorePatterns": ["**\/*.js"]
   * }
   * ```
   */
  ignorePatterns?: string

  /**
   * Ignore stylelint-disable (e.g. `// stylelint-disable block-no-empty`) comments.
   *
   * You can use this option to see what your linting results would be like without those exceptions.
   *
   * @see [Configure ignoreDisables](https://stylelint.io/user-guide/configure#ignoredisables)
   */
  ignoreDisables?: boolean

  /**
   * You can set what configuration comments like `\/* stylelint-disable *\/` start with.
   * This can be useful if you use multiple instances of Stylelint with different configurations.
   *
   * For example, to have an instance of Stylelint disable rules with \/* stylelint-foo-instance-disable *\/ instead of the default \/* stylelint-disable *\/:
   *
   * @see [configuration comment](https://stylelint.io/user-guide/configure#configurationcomment)
   * @example
   * ```json
   * {
   *   "configurationComment": "stylelint-foo-instance"
   * }
   * ```
   */
  configurationComment?: string

  /**
   * Report `stylelint-disable` comments without a description.
   *
   * @see [Report descriptionless disables](https://stylelint.io/user-guide/options#reportdescriptionlessdisables)
   */
  reportDescriptionlessDisables?: DisableSettings

  /**
   * Report `stylelint-disable` comments that don't match rules that are specified in the configuration object.
   *
   * @see [Report invalid scope disables](https://stylelint.io/user-guide/options#reportinvalidscopedisables)
   */
  reportInvalidScopeDisables?: DisableSettings

  /**
   * Report stylelint-disable comments that don't match any lints that need to be disabled.
   *
   * @see [Report needless disables](https://stylelint.io/user-guide/options#reportneedlessdisables)
   */
  reportNeedlessDisables?: DisableSettings

  /**
   * Report configuration comments that are not scoped to at least one rule.
   *
   * @see [Report unscoped disables](https://stylelint.io/user-guide/options#reportunscopeddisables)
   */
  reportUnscopedDisables?: DisableSettings

  /**
   * You can set the default severity level for all rules that do not have a severity specified in their secondary options.
   *
   * @see [Default Severity](https://stylelint.io/user-guide/configure#defaultseverity)
   * @example
   * ```json
   * {
   *   "defaultSeverity": "warning",
   * }
   * ```
   */
  defaultSeverity?: Severity

  /**
   * You can extend an existing configuration (whether your own or a third-party one).
   * Configurations can bundle plugins, custom syntaxes, options, and configure rules.
   * They can also extend other configurations.
   *
   * For example, {@link https://github.com/stylelint/stylelint-config-standard stylelint-config-standard} is one of our official configs that you can extend.
   *
   * When one configuration extends another,
   * it starts with the other's properties and then adds to and overrides what's there.
   *
   * @see [Configure extends](https://stylelint.io/user-guide/configure#extends)
   * @example
   * ```json
   * {
   *   "extends": "stylelint-config-standard",
   * }
   * ```
   */
  extends?: Extends | Extends[]
  /**
   * Plugins are custom rules or sets of custom rules built to support methodologies,
   * toolsets, non-standard CSS features, or very specific use cases.
   *
   * @see [Configure plugins](https://stylelint.io/user-guide/configure#plugins)
   * @example
   * ```json
   * {
   *   "plugins": ["stylelint-scss"],
   * }
   * ```
   */
  plugins?: Plugins

  /**
   * plugin functions
   */
  pluginFunctions?: PluginFunctions
  /**
   * Specify what subset of files to apply a configuration to.
   * - must contain a `files` property, which is an array of glob patterns that specify which files the configuration should be applied to
   * - should contain at least one other regular configuration property, such as `customSyntax`, `rules`, `extends`, etc.
   *
   * @see [Configure overrides](https://stylelint.io/user-guide/configure#overrides)
   */
  overrides?: Override[]

  /**
   * Specify a custom syntax to use on your code.
   *
   * This option allows Stylelint to transform these into something that resembles CSS,
   * which is the language that:
   * - underpins all the other styling languages
   * - is best understood by rules built into Stylelint
   *
   * This option should be a string that resolves to a JS module that exports a
   * {@link https://github.com/postcss/postcss#syntaxes PostCSS-compatible syntax}.
   * The string can be a module name (like `my-module`)
   * or a path to a JS file (like `path/to/my-module.js`).
   *
   * @see [Configure customSyntax](https://stylelint.io/user-guide/options#customsyntax)
   */
  customSyntax?: KnownCustomSyntax | Exclude<CustomSyntax$1, string>

  /**
   * Rules determine what the linter looks for and complains about.
   *
   * @see [Rules](https://stylelint.io/user-guide/rules)
   */
  rules?: Partial<Rules>

  /**
   * @experimental
   * @see [computeEditInfo](https://stylelint.io/user-guide/configure#computeeditinfo)
   */
  computeEditInfo?: boolean

  /**
   * You can customize the syntax to define or extend the syntax for at-rules, properties, types, and CSS-wide keywords.
   * @see [languageOptions](https://stylelint.io/user-guide/configure#languageoptions)
   */
  languageOptions?: LanguageOptions
}

/**
 * Define a Stylelint config.
 *
 * @param config - Stylelint config
 * @returns Stylelint config
 */
declare function defineConfig(config: StylelintConfig): StylelintConfig;

export { type AbsoluteUnit, type AngleUnit, type AtRules, type CSSFunction, type CSSPropertiesMap, type CustomExtends, type CustomPlugins, type CustomRuleOptions, type CustomSyntax, type CustomUnit, type DisableSettings, type Extends, type FrequencyUnit, type KebabCase, type KebabCaseStandardPropertiesMap, type LiteralUnion, type MediaFeature, type MediaFeatureLevel5, type MediaFeatureNormal, type MediaFeaturePrefix, type MediaType, type Override, type PercentUnit, type Prefix, type RegExpLike, type RelativeUnit, type RenamePrefix, type ResolutionUnit, type RuleConfig, type Rules, type SecondaryOptions, type SelectorAttributeOperator, type SelectorCombinator, type SelectorPseudoClass, type SelectorPseudoElement, type StandardPropertiesMap, type StyleLintRules, type StylelintConfig, type TimeUnit, type Unit, type Unprefix, defineConfig as default, defineConfig };