@atlaskit/eslint-plugin-design-system 8.33.0 → 8.36.0

package/dist/types/rules/use-primitives-text/transformers/strong-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const StrongElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types/rules/use-tokens-typography/config/index.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
+export type RuleConfig = {
+    failSilently?: boolean;
+};
+export declare const ruleSchema: JSONSchema4;
+export declare const getConfig: (overrides: RuleConfig) => RuleConfig;

package/dist/types/rules/use-tokens-typography/error-boundary.d.ts

@@ -0,0 +1,11 @@
+import { RuleConfig } from './config';
+/**
+ * ESLint rules should NEVER throw exceptions, because that breaks the VSCode ESLint server
+ * (and probably the IntelliJ one too), which causes linting to fail in a file.
+ *
+ * It also breaks CI, which was the reason this error boundary was added. It's a final
+ * catch all.
+ */
+export declare const errorBoundary: (func: () => void, { config }: {
+    config: RuleConfig;
+}) => void;

package/dist/types/rules/use-tokens-typography/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types/rules/use-tokens-typography/transformers/style-object.d.ts

@@ -0,0 +1,31 @@
+import type { Rule } from 'eslint';
+import { ImportDeclaration, ObjectExpression, Property, StringableASTNode } from 'eslint-codemod-utils';
+import { TokenValueMap } from '../utils';
+interface MetaData {
+    context: Rule.RuleContext;
+}
+interface Refs {
+    fontSizeNode: Property;
+    fontSizeRaw: string | number;
+    tokensImportNode: ImportDeclaration | undefined;
+}
+type Check = {
+    success: boolean;
+    refs?: Refs;
+};
+interface FixerRefs {
+    matchingToken: TokenValueMap;
+    nodesToReplace: Property[];
+    tokensImportNode: ImportDeclaration | undefined;
+    fontWeightReplacement: StringableASTNode<Property> | undefined;
+    fontFamilyReplacement: StringableASTNode<Property> | undefined;
+    fontStyleReplacement: StringableASTNode<Property> | undefined;
+}
+export declare const StyleObject: {
+    lint(node: Rule.Node, { context }: MetaData): {
+        success: boolean;
+    } | undefined;
+    _check(node: ObjectExpression & Rule.NodeParentExtension, { context }: MetaData): Check;
+    _fix(refs: FixerRefs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+};
+export {};

package/dist/types/rules/use-tokens-typography/utils.d.ts

@@ -0,0 +1,194 @@
+import { CallExpression, EslintNode, Property } from 'eslint-codemod-utils';
+export declare const typographyProperties: string[];
+export declare const isTypographyProperty: (propertyName: string) => boolean;
+export declare const isFontSize: (node: EslintNode) => node is CallExpression;
+export declare const isFontSizeSmall: (node: EslintNode) => node is CallExpression;
+export declare const isFontFamily: (node: EslintNode) => node is CallExpression;
+export declare const isCodeFontFamily: (node: EslintNode) => node is CallExpression;
+export type TokenValueMap = {
+    tokenName: string;
+    tokenValue: string;
+    values: {
+        fontSize?: string;
+        fontWeight?: string;
+        lineHeight?: string;
+    };
+};
+export declare const typographyValueToToken: TokenValueMap[];
+export declare function findTypographyTokenForValues(fontSize: string, lineHeight?: string): TokenValueMap[];
+export declare const fontWeightTokens: {
+    tokenName: string;
+    tokenValue: string;
+    values: {};
+}[];
+export declare function findFontWeightTokenForValue(fontWeight: string): {
+    tokenName: string;
+    tokenValue: string;
+    values: {};
+} | undefined;
+export declare const fontWeightMap: FontWeightMap;
+export type FontWeightMap = {
+    regular: string;
+    medium: string;
+    semibold: string;
+    bold: string;
+};
+export declare const defaultFontWeight: string;
+export declare const fontFamilyTokens: ({
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+            deprecated?: undefined;
+        };
+        value: string;
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant: string;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant: string;
+            deprecated?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+            deprecated?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        deprecated: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            deprecated: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        deprecated: string;
+        responsiveSmallerVariant?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            deprecated: string;
+            responsiveSmallerVariant?: undefined;
+        };
+        value: string;
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+})[];
+export declare function findFontFamilyValueForToken(tokenName: string): string;
+export declare function notUndefined<V>(value: V | undefined): value is V;
+export declare function isValidPropertyNode(node: Property): boolean;
+export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function getLiteralProperty(propertyName: string, propertyValue: string): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function convertPropertyNodeToStringableNode(node: Property): import("eslint-codemod-utils").StringableASTNode<Property>;

package/dist/types-ts4.5/ast-nodes/index.d.ts

@@ -3,4 +3,5 @@ export { Import } from './import';
 export { JSXAttribute } from './jsx-attribute';
 export { JSXElement } from './jsx-element';
 export { Object } from './object';
+export { ObjectEntry } from './object-entry';
 export { Root } from './root';

package/dist/types-ts4.5/ast-nodes/object-entry.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from 'eslint';
+import type { Property, SpreadElement } from 'eslint-codemod-utils';
+declare const ObjectEntry: {
+    deleteEntry(node: Property | SpreadElement, context: Rule.RuleContext, fixer: Rule.RuleFixer): Rule.Fix;
+};
+export { ObjectEntry };

package/dist/types-ts4.5/ast-nodes/object.d.ts

@@ -14,7 +14,7 @@ declare const ASTObjectExpression: {
      */
     isFlat(node: ObjectExpression): boolean;
     /**
-     * Returns a key-value pair like: `padding: '8px'` from: `{ padding: '8px' }`.
+     * Returns the first Property node from an Object that matches the provided name.
      */
     getEntryByPropertyName(node: ObjectExpression, name: string): Property | undefined;
     deleteEntry(node: ObjectExpression, name: string, fixer: Rule.RuleFixer): Rule.Fix[];

package/dist/types-ts4.5/index.codegen.d.ts

@@ -32,6 +32,7 @@ export declare const configs: {
             '@atlaskit/design-system/use-href-in-link-item': string;
             '@atlaskit/design-system/use-primitives': string;
             '@atlaskit/design-system/use-primitives-text': string;
+            '@atlaskit/design-system/use-tokens-typography': string;
             '@atlaskit/design-system/use-visually-hidden': string;
         };
     };

package/dist/types-ts4.5/presets/all.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::bcb633b9d5c2def00d43b11139433c5c>>
+ * @codegen <<SignedSource::d90c2cf5e100daf98915f9467f2e5663>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 declare const _default: {
@@ -35,6 +35,7 @@ declare const _default: {
         '@atlaskit/design-system/use-href-in-link-item': string;
         '@atlaskit/design-system/use-primitives': string;
         '@atlaskit/design-system/use-primitives-text': string;
+        '@atlaskit/design-system/use-tokens-typography': string;
         '@atlaskit/design-system/use-visually-hidden': string;
     };
 };

package/dist/types-ts4.5/rules/ensure-design-token-usage/types.d.ts

@@ -1,4 +1,4 @@
-export type Domains = ('color' | 'spacing' | 'typography' | 'shape')[];
+export type Domains = ('color' | 'spacing' | 'shape')[];
 export type RuleConfig = {
     domains: Domains;
     applyImport?: boolean;

package/dist/types-ts4.5/rules/ensure-design-token-usage/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import { EslintNode, ObjectExpression, TaggedTemplateExpression } from 'eslint-codemod-utils';
+import { EslintNode, ObjectExpression, Property, SpreadElement, TaggedTemplateExpression } from 'eslint-codemod-utils';
 import { Domains } from './types';
 export type ProcessedCSSLines = [
     string,
@@ -19,8 +19,8 @@ export declare const isSpacingProperty: (propertyName: string) => boolean;
  * For input `-${gridSize / 2}px ${token(...)} 18px -> [`-${gridSize / 2}px`, `${token(...)}`, `18px`]
  */
 export declare const splitShorthandValues: (str: string) => string[];
-export declare const getValueFromShorthand: (str: unknown) => any[];
-export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | any[] | null | undefined;
+export declare const getValueFromShorthand: (str: unknown) => (string | number)[];
+export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | (string | number)[] | null | undefined;
 export declare const getRawExpression: (node: EslintNode, context: Rule.RuleContext) => string | null;
 /**
  * @example
@@ -46,34 +46,33 @@ export declare const isAuto: (value: string | number | boolean | RegExp | null |
 export declare const convertHyphenatedNameToCamelCase: (prop: string) => string;
 /**
  * @param node
- * @returns The furthest parent node that is on the same line as the input node
+ * @returns The furthest parent node that is on the same line as the input node.
  */
 export declare const findParentNodeForLine: (node: Rule.Node) => Rule.Node;
 /**
- * Returns an array of domains that are relevant to the provided property based on the rule options
+ * Returns an array of domains that are relevant to the provided property based on the rule options.
  * @param propertyName camelCase CSS property
- * @param targetOptions Array containing the types of properties that should be included in the rule
+ * @param targetOptions Array containing the types of properties that should be included in the rule.
  * @example
  * ```
  * propertyName: padding, targetOptions: ['spacing'] -> returns ['spacing']
- * propertyName: fontWeight, targetOptions: ['spacing', 'typography'] -> returns ['typography']
- * propertyName: backgroundColor, targetOptions: ['spacing', 'typography'] -> returns []
+ * propertyName: backgroundColor, targetOptions: ['spacing'] -> returns []
  * propertyName: backgroundColor, targetOptions: ['color', 'spacing'] -> returns ['color']
  * ```
  */
 export declare function getDomainsForProperty(propertyName: string, targetOptions: Domains): Domains;
 /**
  * Function that removes JS comments from a string of code,
- * sometimes makers will have single or multiline comments in their tagged template literals styles, this can mess with our parsing logic
+ * sometimes makers will have single or multiline comments in their tagged template literals styles, this can mess with our parsing logic.
  */
 export declare function cleanComments(str: string): string;
 /**
  * Returns an array of tuples representing a processed css within `TaggedTemplateExpression` node.
- * each element of the array is a tuple `[string, string]`,
+ * Each element of the array is a tuple `[string, string]`,
  * where the first element is the processed css line with computed values
- * and the second element of the tuple is the original css line from source
- * @param node TaggedTemplateExpression node
- * @param context Rule.RuleContext
+ * and the second element of the tuple is the original css line from source.
+ * @param node TaggedTemplateExpression node.
+ * @param context Rule.RuleContext.
  * @example
  * ```
  * `[['padding: 8', 'padding: ${gridSize()}'], ['margin: 6', 'margin: 6px' ]]`
@@ -94,13 +93,13 @@ export declare function getTokenNodeForValue(propertyName: string, value: string
 export declare function getFontSizeValueInScope(cssProperties: ProcessedCSSLines): number | undefined;
 /**
  * Attempts to remove all non-essential words & characters from a style block.
- * Including selectors and queries
+ * Including selectors and queries.
  * @param styleString string of css properties
  */
 export declare function splitCssProperties(styleString: string): string[];
 /**
- * returns whether the current string is a token value
- * @param originalVaue string representing a css property value e.g 1em, 12px
+ * Returns whether the current string is a token value.
+ * @param originalVaue string representing a css property value e.g 1em, 12px.
  */
 export declare function isTokenValueString(originalValue: string): boolean;
 export declare function includesTokenString(originalValue: string): boolean;
@@ -109,17 +108,18 @@ export declare function includesTokenString(originalValue: string): boolean;
  *
  * -> for pixels this '8px'
  * -> for weights     '400'
- * -> for family      'Arial'
+ * -> for family      'Arial'.
  *
  * @internal
  */
-export declare function normaliseValue(propertyName: string, value: string): string;
+export declare function normaliseValue(propertyName: string, value: string | number): string;
 export declare function findTokenNameByPropertyValue(propertyName: string, value: string): string | undefined;
 /**
  * Returns a stringifiable node with the token expression corresponding to its matching token.
- * if no token found for the pair the function returns undefined
- * @param propertyName string camelCased css property
- * @param value the computed value e.g '8px' -> '8'
+ * If no token found for the pair the function returns undefined.
+ * @param propertyName string camelCased css property.
+ * @param value The computed value e.g '8px' -> '8'.
  */
 export declare function getTokenReplacement(propertyName: string, value: string): import("eslint-codemod-utils").StringableASTNode<import("estree").SimpleCallExpression> | undefined;
-export declare function getFontSizeFromNode(parentNode: ObjectExpression & Rule.NodeParentExtension, context: Rule.RuleContext): any;
+export declare function getPropertyNodeFromParent(property: string, parentNode: ObjectExpression & Rule.NodeParentExtension): Property | SpreadElement | undefined;
+export declare function getValueForPropertyNode(propertyNode: Property | SpreadElement, context: Rule.RuleContext): string | number | null | undefined;

package/dist/types-ts4.5/rules/index.codegen.d.ts

@@ -36,6 +36,7 @@ declare const _default: {
     'use-href-in-link-item': import("eslint").Rule.RuleModule;
     'use-primitives': import("eslint").Rule.RuleModule;
     'use-primitives-text': import("eslint").Rule.RuleModule;
+    'use-tokens-typography': import("eslint").Rule.RuleModule;
     'use-visually-hidden': import("eslint").Rule.RuleModule;
 };
 export default _default;

package/dist/types-ts4.5/rules/use-primitives/config/index.d.ts

@@ -1,4 +1,4 @@
-type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties';
+type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties' | 'jsx-order-fix';
 export interface RuleConfig {
     patterns: Pattern[];
 }

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/find-valid-jsx-usage-to-transform.d.ts

@@ -3,5 +3,7 @@ import { JSXOpeningElement } from 'eslint-codemod-utils';
 /**
  * Given a component name finds its JSX usages and performs some
  * additional validations to ensure transformation can be done correctly
+ *
+ * anyOrder: if true, the order of the references doesn't matter (JSX or style declaration)
  */
-export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;
+export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope, anyOrder?: boolean) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/index.d.ts

@@ -20,6 +20,6 @@ export declare const CompiledStyled: {
      * All required validation steps have been taken care of before this
      * transformer is called, so it just goes ahead providing all necessary fixes
      */
-    _fix(refs: Refs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+    _fix(refs: Refs, context: Rule.RuleContext): Rule.ReportFixer;
 };
 export {};

package/dist/types-ts4.5/rules/use-primitives/transformers/emotion-css/index.d.ts

@@ -5,12 +5,11 @@ interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;
 }
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const EmotionCSS: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: Rule.Node, { context, config }: MetaData): boolean;
     _fix(node: JSXElement, { context }: {
         context: Rule.RuleContext;
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types-ts4.5/rules/use-primitives-text/config/index.d.ts

@@ -1,6 +1,7 @@
 type Pattern = 'paragraph-elements' | 'span-elements' | 'strong-elements' | 'emphasis-elements';
 export interface RuleConfig {
     patterns: Pattern[];
+    inheritColor: boolean;
 }
 export declare const getConfig: (overrides: Partial<RuleConfig>) => Required<RuleConfig>;
 export {};

package/dist/types-ts4.5/rules/use-primitives-text/transformers/common.d.ts

@@ -1,5 +1,11 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
+import { RuleConfig } from '../config';
+export type MetaData = {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+};
 export declare function updateTestIdAttributeFix(node: JSXElement, fixer: Rule.RuleFixer): Rule.Fix | undefined;
+export declare function addColorInheritAttributeFix(node: JSXElement, config: RuleConfig, fixer: Rule.RuleFixer): Rule.Fix | undefined;
 export declare const allowedAttrs: string[];
 export declare function hasTextChildrenOnly(node: JSXElement): boolean;

package/dist/types-ts4.5/rules/use-primitives-text/transformers/emphasis-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const EmphasisElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types-ts4.5/rules/use-primitives-text/transformers/paragraph-elements.d.ts

@@ -1,17 +1,12 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-type MetaData = {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-};
+import { type MetaData } from './common';
 type CheckResult = {
     success: boolean;
     refs: {
         siblings: JSXElement['children'];
     };
 };
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const ParagraphElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement & {
@@ -19,14 +14,11 @@ export declare const ParagraphElements: {
     }, { context, config }: MetaData): CheckResult;
     _fixSingle(node: JSXElement & {
         parent: Rule.Node;
-    }, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    }, { context, config }: MetaData): Rule.ReportFixer;
     _fixMultiple(node: JSXElement & {
         parent: Rule.Node;
-    }, { context, refs }: {
-        context: Rule.RuleContext;
+    }, { context, config, refs }: MetaData & {
         refs: CheckResult['refs'];
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types-ts4.5/rules/use-primitives-text/transformers/span-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const SpanElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types-ts4.5/rules/use-primitives-text/transformers/strong-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const StrongElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types-ts4.5/rules/use-tokens-typography/config/index.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
+export type RuleConfig = {
+    failSilently?: boolean;
+};
+export declare const ruleSchema: JSONSchema4;
+export declare const getConfig: (overrides: RuleConfig) => RuleConfig;

package/dist/types-ts4.5/rules/use-tokens-typography/error-boundary.d.ts

@@ -0,0 +1,11 @@
+import { RuleConfig } from './config';
+/**
+ * ESLint rules should NEVER throw exceptions, because that breaks the VSCode ESLint server
+ * (and probably the IntelliJ one too), which causes linting to fail in a file.
+ *
+ * It also breaks CI, which was the reason this error boundary was added. It's a final
+ * catch all.
+ */
+export declare const errorBoundary: (func: () => void, { config }: {
+    config: RuleConfig;
+}) => void;

package/dist/types-ts4.5/rules/use-tokens-typography/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;