stylelint

const stylelint: any;

type Config = {
    extends?: ConfigExtends;
    plugins?: ConfigPlugins;
    pluginFunctions?: {
        [pluginName: string]: Rule;
    };
    ignoreFiles?: ConfigIgnoreFiles;
    ignorePatterns?: string;
    rules?: ConfigRules;
    quiet?: boolean;
    formatter?: FormatterType | Formatter;
    defaultSeverity?: Severity;
    ignoreDisables?: boolean;
    reportNeedlessDisables?: DisableSettings;
    reportInvalidScopeDisables?: DisableSettings;
    reportDescriptionlessDisables?: DisableSettings;
    reportUnscopedDisables?: DisableSettings;
    configurationComment?: string;
    overrides?: ConfigOverride[];
    customSyntax?: CustomSyntax;
    processors?: ConfigProcessors;
    /** @internal */
    _processorFunctions?: Map<string, ReturnType<Processor>['postprocess']>;
    allowEmptyInput?: boolean;
    cache?: boolean;
    fix?: boolean;
    validate?: boolean;
};

type CoreRule<P extends Primary, S extends Secondary = any> = Rule<P, S>;

type CssSyntaxError = {
    file?: string;
    input: {
        column: number;
        file?: string;
        line: number;
        source: string;
    };
    /**
     * The line of the inclusive start position of the error.
     */
    line: number;
    /**
     * The column of the inclusive start position of the error.
     */
    column: number;
    /**
     * The line of the exclusive end position of the error.
     */
    endLine?: number;
    /**
     * The column of the exclusive end position of the error.
     */
    endColumn?: number;
    message: string;
    name: string;
    reason: string;
    source: string;
};

type FixerData = {
    range?: Range;
    fixed: boolean;
};

type Formatters = {
    readonly compact: Promise<Formatter>;
    /** @deprecated */
    readonly github: Promise<Formatter>;
    readonly json: Promise<Formatter>;
    readonly string: Promise<Formatter>;
    readonly tap: Promise<Formatter>;
    readonly unix: Promise<Formatter>;
    readonly verbose: Promise<Formatter>;
};

type LinterOptions = {
    files?: OneOrMany<string>;
    globbyOptions?: GlobbyOptions;
    cache?: boolean;
    cacheLocation?: string;
    cacheStrategy?: string;
    code?: string;
    codeFilename?: string;
    config?: Config;
    configFile?: string;
    configBasedir?: string;
    /**
     * The working directory to resolve files from. Defaults to the
     * current working directory.
     */
    cwd?: string;
    ignoreDisables?: boolean;
    ignorePath?: OneOrMany<string>;
    ignorePattern?: string[];
    reportDescriptionlessDisables?: boolean;
    reportNeedlessDisables?: boolean;
    reportInvalidScopeDisables?: boolean;
    reportUnscopedDisables?: boolean;
    maxWarnings?: number;
    customSyntax?: CustomSyntax;
    /** @internal */
    _defaultFormatter?: FormatterType;
    formatter?: FormatterType | Formatter;
    disableDefaultIgnores?: boolean;
    fix?: boolean;
    allowEmptyInput?: boolean;
    quiet?: boolean;
    quietDeprecationWarnings?: boolean;
    validate?: boolean;
};

type LinterResult = {
    /**
     * The working directory from which the linter was run when the
     * results were generated.
     */
    cwd: string;
    results: LintResult[];
    errored: boolean;
    /**
     * @deprecated Use `report` for the formatted problems, or use `code`
     *   for the autofixed code instead. This will be removed in the next major version.
     */
    output: string;
    /** @internal To show the deprecation warning. */
    _output?: string;
    /** @internal To show the deprecation warning. */
    _outputWarned?: boolean;
    /**
     * A string that contains the formatted problems.
     */
    report: string;
    /**
     * A string that contains the autofixed code, if the `fix` option is set to `true`
     * and the `code` option is provided.
     */
    code?: string;
    maxWarningsExceeded?: {
        maxWarnings: number;
        foundWarnings: number;
    };
    reportedDisables: DisableOptionsReport;
    descriptionlessDisables?: DisableOptionsReport;
    needlessDisables?: DisableOptionsReport;
    invalidScopeDisables?: DisableOptionsReport;
    /**
     * Each rule metadata by name.
     */
    ruleMetadata: { [ruleName: string]: Partial<RuleMeta> };
};

type LintResult = {
    source?: string;
    deprecations: {
        text: string;
        reference?: string;
    }[];
    invalidOptionWarnings: {
        text: string;
    }[];
    parseErrors: (PostCSS.Warning & {
        stylelintType: Extract<StylelintWarningType, 'parseError'>;
    })[];
    errored?: boolean;
    warnings: Warning[];
    ignored?: boolean;
    /**
     * Internal use only. Do not use or rely on this property. It may
     * change at any time.
     * @internal
     */
    _postcssResult?: PostcssResult;
};

type OneOrMany<S> = S | S[];

type Plugin =
    | { default?: { ruleName: string; rule: Rule } }
    | { ruleName: string; rule: Rule };

type Position = {
    line: number;
    column: number;
};

type Primary = number | true | OneOrMany<StringOrRegex> | Record<string, any>;

type Problem = {
    ruleName: string;
    result: PostcssResult;
    message: RuleMessage;
    messageArgs?: Parameters<RuleMessageFunc> | undefined;
    node: PostCSS.Node;
    /**
     * The inclusive start index of the problem, relative to the node's
     * source text.
     */
    index?: number;
    /**
     * The exclusive end index of the problem, relative to the node's
     * source text.
     */
    endIndex?: number;
    /**
     * The inclusive start position of the problem, relative to the
     * node's source text. If provided, this will be used instead of
     * `index`.
     */
    start?: Position;
    /**
     * The exclusive end position of the problem, relative to the
     * node's source text. If provided, this will be used instead of
     * `endIndex`.
     */
    end?: Position;
    word?: string;
    line?: number;
    /**
     * Optional severity override for the problem.
     */
    severity?: RuleSeverity;
    fix?: () => void | undefined | never;
};

type Processor = () => {
    name: string;
    postprocess: (result: LintResult, root?: PostCSS.Root) => void;
};

type PublicApi = PostCSS.PluginCreator<PostcssPluginOptions> & {
    /**
     * Runs Stylelint with the given options and returns a Promise that
     * resolves to the results.
     *
     * @param options - A lint options object
     * @returns A lint result
     */
    lint: (options: LinterOptions) => Promise<LinterResult>;

    /**
     * Available rules.
     */
    rules: { readonly [name in keyof CoreRules]: Promise<CoreRules[name]> };

    /**
     * Result report formatters by name.
     */
    formatters: Formatters;

    /**
     * Creates a Stylelint plugin.
     */
    createPlugin: (ruleName: string, rule: Rule) => Plugin;

    /**
     * The Stylelint "internal API" is passed among functions
     * so that methods on a Stylelint instance can invoke
     * each other while sharing options and caches.
     *
     * @internal
     */
    _createLinter: (options: LinterOptions) => InternalApi;

    /**
     * Resolves the effective configuration for a given file. Resolves to
     * `undefined` if no config is found.
     *
     * @param filePath - The path to the file to get the config for.
     * @param options - The options to use when creating the Stylelint instance.
     * @returns A resolved config or `undefined`.
     */
    resolveConfig: (
        filePath: string,
        options?: Pick<
            LinterOptions,
            'cwd' | 'config' | 'configBasedir' | 'configFile'
        >
    ) => Promise<Config | undefined>;

    /**
     * Utility functions.
     */
    utils: Utils;

    /**
     * Reference objects.
     */
    reference: {
        longhandSubPropertiesOfShorthandProperties: LonghandSubPropertiesOfShorthandProperties;
    };
};

type Rule<P = any, S = any> = RuleBase<P, S> & {
    ruleName: string;
    messages: RuleMessages;
    primaryOptionArray?: boolean;
    meta?: RuleMeta;
};

type RuleContext = {
    configurationComment?: string | undefined;
    fix?: boolean | undefined;
    newline?: string | undefined;
};

type Secondary = Record<string, any>;

type Severity = 'warning' | 'error';

type StringOrRegex = string | RegExp;

type StylelintWarningType = 'deprecation' | 'invalidOption' | 'parseError';

type Utils = {
    /**
     * Report a problem.
     *
     * This function accounts for `disabledRanges` attached to the result.
     * That is, if the reported problem is within a disabledRange,
     * it is ignored. Otherwise, it is attached to the result as a
     * postcss warning.
     *
     * It also accounts for the rule's severity.
     *
     * You *must* pass *either* a node or a line number.
     *
     * @param problem - A problem
     */
    report: (problem: Problem) => void;

    /**
     * Given an object of problem messages, return another
     * that provides the same messages postfixed with the rule
     * that has been violated.
     *
     * @param ruleName - A rule name
     * @param messages - An object whose keys are message identifiers
     *   and values are either message strings or functions that return message strings
     * @returns New message object, whose messages will be marked with the rule name
     */
    ruleMessages: <T extends RuleMessages, R extends { [K in keyof T]: T[K] }>(
        ruleName: string,
        messages: T
    ) => R;

    /**
     * Validate a rule's options.
     *
     * See existing rules for examples.
     *
     * @param result - PostCSS result
     * @param ruleName - A rule name
     * @param optionDescriptions - Each optionDescription can have the following properties:
     *   - `actual` (required): the actual passed option value or object.
     *   - `possible` (required): a schema representation of what values are
     *      valid for those options. `possible` should be an object if the
     *      options are an object, with corresponding keys; if the options are not an
     *      object, `possible` isn't, either. All `possible` value representations
     *      should be **arrays of either values or functions**. Values are === checked
     *      against `actual`. Functions are fed `actual` as an argument and their
     *      return value is interpreted: truthy = valid, falsy = invalid.
     *    - `optional` (optional): If this is `true`, `actual` can be undefined.
     * @returns Whether or not the options are valid (`true` = valid)
     */
    validateOptions: (
        result: PostcssResult,
        ruleName: string,
        ...optionDescriptions: RuleOptions[]
    ) => boolean;

    /**
     * Useful for third-party code (e.g. plugins) to run a PostCSS Root
     * against a specific rule and do something with the warnings.
     */
    checkAgainstRule: <T, O extends Object>(
        options: {
            ruleName: string;
            ruleSettings: ConfigRuleSettings<T, O>;
            root: PostCSS.Root;
            result?: PostcssResult;
            context?: RuleContext;
        },
        callback: (warning: PostCSS.Warning) => void
    ) => Promise<void>;
};

type Warning = {
    /**
     * The line of the inclusive start position of the warning.
     */
    line: number;
    /**
     * The column of the inclusive start position of the warning.
     */
    column: number;
    /**
     * The line of the exclusive end position of the warning.
     */
    endLine?: number;
    /**
     * The column of the exclusive end position of the warning.
     */
    endColumn?: number;
    rule: string;
    severity: Severity;
    text: string;
    url?: string;
    stylelintType?: StylelintWarningType;
};