@reasonabletech/eslint-config 0.1.0

package/dist/src/custom-rules/null-undefined-checks.js

@@ -0,0 +1,153 @@
+/**
+ * Custom ESLint rule: no-null-undefined-checks
+ *
+ * Flags code that checks for both null and undefined on the same value,
+ * which indicates a type mismatch. null and undefined are different types
+ * in TypeScript, and you should only check for what's in your type union.
+ */
+import { ESLintUtils, AST_NODE_TYPES, } from "@typescript-eslint/utils";
+/**
+ * Type guard for BinaryExpression
+ * @param node The node to check
+ * @returns True if the node is a BinaryExpression
+ */
+function isBinaryExpression(node) {
+    return node.type === AST_NODE_TYPES.BinaryExpression;
+}
+/**
+ * Type guard for Identifier
+ * @param node The node to check
+ * @returns True if the node is an Identifier
+ */
+function isIdentifier(node) {
+    return node.type === AST_NODE_TYPES.Identifier;
+}
+/**
+ * Type guard for Literal
+ * @param node The node to check
+ * @returns True if the node is a Literal
+ */
+function isLiteral(node) {
+    return node.type === AST_NODE_TYPES.Literal;
+}
+/**
+ * Checks if a node is a null comparison (=== null, !== null, == null, != null)
+ * @param node The node to check
+ * @returns The variable being compared to null, or null if not a null comparison
+ */
+function getNullCheckVariable(node) {
+    if (!isBinaryExpression(node)) {
+        return null;
+    }
+    const { operator, left, right } = node;
+    const isComparisonOp = operator === "===" ||
+        operator === "!==" ||
+        operator === "==" ||
+        operator === "!=";
+    if (!isComparisonOp) {
+        return null;
+    }
+    // Check if right side is null literal
+    if (isLiteral(right) && right.value === null && isIdentifier(left)) {
+        return left.name;
+    }
+    // Check if left side is null literal
+    if (isLiteral(left) && left.value === null && isIdentifier(right)) {
+        return right.name;
+    }
+    return null;
+}
+/**
+ * Checks if a node is an undefined comparison (=== undefined, !== undefined, == undefined, != undefined)
+ * @param node The node to check
+ * @returns The variable being compared to undefined, or null if not an undefined comparison
+ */
+function getUndefinedCheckVariable(node) {
+    if (!isBinaryExpression(node)) {
+        return null;
+    }
+    const { operator, left, right } = node;
+    const isComparisonOp = operator === "===" ||
+        operator === "!==" ||
+        operator === "==" ||
+        operator === "!=";
+    if (!isComparisonOp) {
+        return null;
+    }
+    // Check if right side is undefined identifier
+    if (isIdentifier(right) && right.name === "undefined" && isIdentifier(left)) {
+        return left.name;
+    }
+    // Check if left side is undefined identifier
+    if (isIdentifier(left) && left.name === "undefined" && isIdentifier(right)) {
+        return right.name;
+    }
+    return null;
+}
+/**
+ * Creates the no-null-undefined-checks rule
+ */
+export const noNullUndefinedChecksRule = ESLintUtils.RuleCreator(() => "docs/standards/typescript-design-patterns.md")({
+    name: "no-null-undefined-checks",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Flags checking for both null and undefined on the same value, which indicates a type mismatch. null and undefined are different types in TypeScript.",
+        },
+        messages: {
+            checksBoth: "Checking for both null and undefined suggests a type mismatch. Simplify the type: use `T | null` for nullable values, or `T | undefined` for optional values. If both are genuinely in the type, use `x == null` which covers both in a single check.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            LogicalExpression(node) {
+                // Only check OR conditions (||)
+                if (node.operator !== "||") {
+                    return;
+                }
+                // Get the variables being checked on each side
+                const leftNullVar = getNullCheckVariable(node.left);
+                const leftUndefinedVar = getUndefinedCheckVariable(node.left);
+                const rightNullVar = getNullCheckVariable(node.right);
+                const rightUndefinedVar = getUndefinedCheckVariable(node.right);
+                // Look for a variable that appears in both null and undefined checks
+                const nullVars = new Set();
+                const undefinedVars = new Set();
+                if (leftNullVar !== null) {
+                    nullVars.add(leftNullVar);
+                }
+                if (rightNullVar !== null) {
+                    nullVars.add(rightNullVar);
+                }
+                if (leftUndefinedVar !== null) {
+                    undefinedVars.add(leftUndefinedVar);
+                }
+                if (rightUndefinedVar !== null) {
+                    undefinedVars.add(rightUndefinedVar);
+                }
+                // Check if any variable is checked against both null and undefined
+                for (const variable of nullVars) {
+                    if (undefinedVars.has(variable)) {
+                        context.report({
+                            node,
+                            messageId: "checksBoth",
+                        });
+                        break;
+                    }
+                }
+            },
+        };
+    },
+});
+/**
+ * Creates the rule configuration for the null/undefined checks rule
+ * @returns ESLint rule configuration
+ */
+export function createNullUndefinedChecksRules() {
+    return {
+        "@reasonabletech/no-null-undefined-checks": "error",
+    };
+}
+//# sourceMappingURL=null-undefined-checks.js.map

package/dist/src/custom-rules/platform-conventions.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Platform-specific convention rules
+ *
+ * These rules enforce conventions specific to the platform's
+ * standard library and architectural patterns, ensuring consistent use
+ * of platform utilities across the codebase.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import type { Linter } from "eslint";
+import { type UILibraryImportRuleOptions } from "./ui-library-imports.js";
+/**
+ * Configuration options for platform convention rules
+ */
+export interface PlatformConventionRuleOptions {
+    /** Base URL for documentation references */
+    docBaseUrl?: string;
+    /** Whether to enforce Result helper usage (default: true) */
+    enforceResultHelpers?: boolean;
+    /**
+     * Legacy alias for discouraging UI library barrel imports.
+     * Prefer `discourageUILibraryBarrelImports`.
+     */
+    discourageUIBarrelImports?: boolean;
+    /**
+     * UI import boundary options for the shared UI library.
+     */
+    uiImportBoundaries?: UILibraryImportRuleOptions;
+}
+/**
+ * Custom ESLint rule that enforces using ok() and err() helpers from `@reasonabletech/utils`
+ *
+ * This rule prevents manual Result object construction, ensuring developers use
+ * the platform's standard utility functions for consistency and type safety.
+ *
+ * **Core Principle**: Always use ok() and err() helpers for Result types instead
+ * of manually constructing objects with { success: true/false, ... }
+ *
+ * ❌ FORBIDDEN (Manual Result construction):
+ * ```typescript
+ * // Wrong: Manual success result
+ * return { success: true, data: user };
+ *
+ * // Wrong: Manual error result
+ * return { success: false, error: "not_found" };
+ *
+ * // Wrong: Inline object literals
+ * const result = { success: true, data: value };
+ * ```
+ *
+ * ✅ CORRECT (Using platform helpers):
+ * ```typescript
+ * // Right: Use ok() for success
+ * import { ok } from "@reasonabletech/utils";
+ * return ok(user);
+ *
+ * // Right: Use err() for errors
+ * import { err } from "@reasonabletech/utils";
+ * return err("not_found");
+ *
+ * // Right: Import and use consistently
+ * import { ok, err, type Result } from "@reasonabletech/utils";
+ *
+ * async function getUser(id: string): Promise<Result<User, "not_found">> {
+ *   const user = await db.user.findUnique({ where: { id } });
+ *   if (!user) return err("not_found");
+ *   return ok(user);
+ * }
+ * ```
+ *
+ * **Why this matters**:
+ * - Ensures consistent Result construction across the platform
+ * - Leverages type inference from helper functions
+ * - Makes refactoring easier (change implementation in one place)
+ * - Provides better editor autocomplete and type checking
+ * - Prevents typos in manual object construction ({ sucess: true })
+ */
+export declare const useResultHelpersRule: ESLintUtils.RuleModule<"useOkHelper" | "useErrHelper", [{
+    docBaseUrl: string;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+/**
+ * Creates rules that enforce Result helper usage
+ *
+ * Uses the `@reasonabletech/use-result-helpers` custom rule which detects manual
+ * Result construction including non-literal success values, spread elements,
+ * and computed property keys.
+ * @param options Configuration options for platform convention rules
+ * @returns ESLint rules that enforce Result helper usage
+ */
+export declare function createResultHelperRules(options?: PlatformConventionRuleOptions): Linter.RulesRecord;
+/**
+ * Creates UI library import-boundary rules.
+ *
+ * This is a thin adapter that keeps the platform-conventions API stable while
+ * delegating UI-library specifics to the dedicated `ui-library-imports` module.
+ * @param options Configuration options for platform convention rules
+ * @returns ESLint rules that discourage UI library barrel imports
+ */
+export declare function createUIBarrelImportRules(options?: PlatformConventionRuleOptions): Linter.RulesRecord;
+/**
+ * Creates a complete set of platform convention rules
+ *
+ * This is the main function that combines all platform-specific convention
+ * rules into a single configuration object.
+ * @param options Configuration options for platform convention rules
+ * @returns Complete set of platform convention ESLint rules
+ */
+export declare function createPlatformConventionRules(options?: PlatformConventionRuleOptions): Linter.RulesRecord;
+/**
+ * Preset for platform convention rules
+ * @returns ESLint rules configured for platform conventions
+ */
+export declare function createPlatformConventionPresetRules(): Linter.RulesRecord;
+//# sourceMappingURL=platform-conventions.d.ts.map

package/dist/src/custom-rules/platform-conventions.js

@@ -0,0 +1,249 @@
+/**
+ * Platform-specific convention rules
+ *
+ * These rules enforce conventions specific to the platform's
+ * standard library and architectural patterns, ensuring consistent use
+ * of platform utilities across the codebase.
+ */
+import { AST_NODE_TYPES, ESLintUtils, } from "@typescript-eslint/utils";
+import { mergeRuleConfigurations } from "./utils.js";
+import { createUILibraryImportRules, } from "./ui-library-imports.js";
+/**
+ * Default configuration for platform convention rules
+ */
+const DEFAULT_OPTIONS = {
+    docBaseUrl: "",
+    enforceResultHelpers: true,
+    discourageUIBarrelImports: true,
+    uiImportBoundaries: {
+        discourageUILibraryBarrelImports: true,
+    },
+};
+/**
+ * Custom ESLint rule that enforces using ok() and err() helpers from `@reasonabletech/utils`
+ *
+ * This rule prevents manual Result object construction, ensuring developers use
+ * the platform's standard utility functions for consistency and type safety.
+ *
+ * **Core Principle**: Always use ok() and err() helpers for Result types instead
+ * of manually constructing objects with { success: true/false, ... }
+ *
+ * ❌ FORBIDDEN (Manual Result construction):
+ * ```typescript
+ * // Wrong: Manual success result
+ * return { success: true, data: user };
+ *
+ * // Wrong: Manual error result
+ * return { success: false, error: "not_found" };
+ *
+ * // Wrong: Inline object literals
+ * const result = { success: true, data: value };
+ * ```
+ *
+ * ✅ CORRECT (Using platform helpers):
+ * ```typescript
+ * // Right: Use ok() for success
+ * import { ok } from "@reasonabletech/utils";
+ * return ok(user);
+ *
+ * // Right: Use err() for errors
+ * import { err } from "@reasonabletech/utils";
+ * return err("not_found");
+ *
+ * // Right: Import and use consistently
+ * import { ok, err, type Result } from "@reasonabletech/utils";
+ *
+ * async function getUser(id: string): Promise<Result<User, "not_found">> {
+ *   const user = await db.user.findUnique({ where: { id } });
+ *   if (!user) return err("not_found");
+ *   return ok(user);
+ * }
+ * ```
+ *
+ * **Why this matters**:
+ * - Ensures consistent Result construction across the platform
+ * - Leverages type inference from helper functions
+ * - Makes refactoring easier (change implementation in one place)
+ * - Provides better editor autocomplete and type checking
+ * - Prevents typos in manual object construction ({ sucess: true })
+ */
+export const useResultHelpersRule = ESLintUtils.RuleCreator(() => "")({
+    name: "use-result-helpers",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Enforces using ok() and err() helpers from @reasonabletech/utils instead of manual Result construction",
+        },
+        messages: {
+            useOkHelper: "❌ FORBIDDEN: Use ok() from @reasonabletech/utils instead of manually constructing { success: true, data: ... }",
+            useErrHelper: "❌ FORBIDDEN: Use err() from @reasonabletech/utils instead of manually constructing { success: false, error: ... }",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    docBaseUrl: {
+                        type: "string",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            docBaseUrl: "",
+        },
+    ],
+    create(context) {
+        /**
+         * Checks if an object expression looks like a manual Result construction
+         * @param node - AST node representing an object expression
+         * @returns True if the object looks like a Result type
+         */
+        function isResultLikeObject(node) {
+            let hasSuccess = false;
+            let successValue = null;
+            let hasData = false;
+            let hasError = false;
+            for (const prop of node.properties) {
+                if (prop.type === AST_NODE_TYPES.Property &&
+                    prop.key.type === AST_NODE_TYPES.Identifier) {
+                    const keyName = prop.key.name;
+                    if (keyName === "success") {
+                        hasSuccess = true;
+                        // Try to determine if success is true or false
+                        if (prop.value.type === AST_NODE_TYPES.Literal &&
+                            typeof prop.value.value === "boolean") {
+                            successValue = prop.value.value;
+                        }
+                    }
+                    else if (keyName === "data") {
+                        hasData = true;
+                    }
+                    else if (keyName === "error") {
+                        hasError = true;
+                    }
+                }
+            }
+            // Result type has 'success' and either 'data' or 'error'
+            const isResult = hasSuccess && (hasData || hasError);
+            return { isResult, isSuccess: successValue };
+        }
+        return {
+            ObjectExpression(node) {
+                const { isResult, isSuccess } = isResultLikeObject(node);
+                if (!isResult) {
+                    return;
+                }
+                // Check if this is a success result (use ok helper)
+                if (isSuccess === true) {
+                    context.report({
+                        node,
+                        messageId: "useOkHelper",
+                    });
+                }
+                // Check if this is an error result (use err helper)
+                if (isSuccess === false) {
+                    context.report({
+                        node,
+                        messageId: "useErrHelper",
+                    });
+                }
+                // If we can't determine the success value (e.g., variable), still report
+                // because manual construction should be avoided
+                if (isSuccess === null) {
+                    // Check which property exists to give better message
+                    const hasData = node.properties.some((prop) => prop.type === AST_NODE_TYPES.Property &&
+                        prop.key.type === AST_NODE_TYPES.Identifier &&
+                        prop.key.name === "data");
+                    if (hasData) {
+                        context.report({
+                            node,
+                            messageId: "useOkHelper",
+                        });
+                    }
+                    else {
+                        context.report({
+                            node,
+                            messageId: "useErrHelper",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+/**
+ * Creates rules that enforce Result helper usage
+ *
+ * Uses the `@reasonabletech/use-result-helpers` custom rule which detects manual
+ * Result construction including non-literal success values, spread elements,
+ * and computed property keys.
+ * @param options Configuration options for platform convention rules
+ * @returns ESLint rules that enforce Result helper usage
+ */
+export function createResultHelperRules(options = {}) {
+    const config = { ...DEFAULT_OPTIONS, ...options };
+    if (!config.enforceResultHelpers) {
+        return {};
+    }
+    return {
+        "@reasonabletech/use-result-helpers": [
+            "error",
+            {
+                docBaseUrl: config.docBaseUrl,
+            },
+        ],
+    };
+}
+/**
+ * Creates UI library import-boundary rules.
+ *
+ * This is a thin adapter that keeps the platform-conventions API stable while
+ * delegating UI-library specifics to the dedicated `ui-library-imports` module.
+ * @param options Configuration options for platform convention rules
+ * @returns ESLint rules that discourage UI library barrel imports
+ */
+export function createUIBarrelImportRules(options = {}) {
+    const config = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        uiImportBoundaries: {
+            ...DEFAULT_OPTIONS.uiImportBoundaries,
+            ...options.uiImportBoundaries,
+        },
+    };
+    return createUILibraryImportRules({
+        discourageUILibraryBarrelImports: (config.uiImportBoundaries.discourageUILibraryBarrelImports ?? true) &&
+            config.discourageUIBarrelImports,
+    });
+}
+/**
+ * Creates a complete set of platform convention rules
+ *
+ * This is the main function that combines all platform-specific convention
+ * rules into a single configuration object.
+ * @param options Configuration options for platform convention rules
+ * @returns Complete set of platform convention ESLint rules
+ */
+export function createPlatformConventionRules(options = {}) {
+    const resultHelperRules = createResultHelperRules(options);
+    const uiBarrelImportRules = createUIBarrelImportRules(options);
+    return mergeRuleConfigurations(resultHelperRules, uiBarrelImportRules);
+}
+/**
+ * Preset for platform convention rules
+ * @returns ESLint rules configured for platform conventions
+ */
+export function createPlatformConventionPresetRules() {
+    return createPlatformConventionRules({
+        docBaseUrl: "",
+        enforceResultHelpers: true,
+        discourageUIBarrelImports: true,
+        uiImportBoundaries: {
+            discourageUILibraryBarrelImports: true,
+        },
+    });
+}
+//# sourceMappingURL=platform-conventions.js.map

package/dist/src/custom-rules/test-quality.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Test quality rule definitions for ReasonableTech projects
+ *
+ * These rules prevent low-value test patterns that inflate coverage
+ * metrics without verifying real behavior. They are specifically designed
+ * to catch AI-generated test anti-patterns.
+ */
+import type { Linter } from "eslint";
+/**
+ * Creates ESLint rules that ban `expect(typeof <expr>).<matcher>(...)` patterns.
+ *
+ * These assertions only verify that JavaScript knows the type of an expression
+ * at the time the test runs — information that TypeScript already guarantees at
+ * compile time. They are a classic AI-generated coverage-padding anti-pattern.
+ *
+ * ❌ FORBIDDEN:
+ * ```typescript
+ * expect(typeof tabula.close).toBe("function");
+ * expect(typeof result).toBe("object");
+ * expect(typeof user.name).toEqual("string");
+ * ```
+ *
+ * ✅ CORRECT: test observable behaviour
+ * ```typescript
+ * // Call the function and assert what it does
+ * await tabula.close();
+ * expect(tabula.isClosed()).toBe(true);
+ *
+ * // Assert the shape of a result
+ * expect(result).toMatchObject({ id: expect.any(String) });
+ *
+ * // Assert the value, not the type
+ * expect(user.name).toBe("Alice");
+ * ```
+ * @returns ESLint rules that prevent typeof-in-expect patterns
+ */
+export declare function createNoTypeofInExpectRules(): Linter.RulesRecord;
+//# sourceMappingURL=test-quality.d.ts.map

package/dist/src/custom-rules/test-quality.js

@@ -0,0 +1,68 @@
+/**
+ * Test quality rule definitions for ReasonableTech projects
+ *
+ * These rules prevent low-value test patterns that inflate coverage
+ * metrics without verifying real behavior. They are specifically designed
+ * to catch AI-generated test anti-patterns.
+ */
+/**
+ * AST selector matching `expect(typeof <expr>).<matcher>(...)`.
+ *
+ * The pattern:
+ * - Outer CallExpression  → the matcher call, e.g. `.toBe("function")`
+ * - callee is a MemberExpression whose object is a CallExpression to `expect`
+ * - The argument passed to `expect` is a UnaryExpression with operator `"typeof"`
+ *
+ * This catches all variants regardless of the matcher used:
+ * `expect(typeof x).toBe("function")`
+ * `expect(typeof x).toEqual("object")`
+ * `expect(typeof x).toStrictEqual("string")`
+ */
+const TYPEOF_IN_EXPECT_SELECTOR = 'CallExpression[callee.type="MemberExpression"]' +
+    '[callee.object.type="CallExpression"]' +
+    '[callee.object.callee.name="expect"]' +
+    '[callee.object.arguments.0.type="UnaryExpression"]' +
+    '[callee.object.arguments.0.operator="typeof"]';
+const NO_TYPEOF_IN_EXPECT_MESSAGE = "❌ FORBIDDEN: expect(typeof x).toBe(...) adds zero test value and hides real" +
+    " gaps in functionality. Test observable behaviour instead — call the function," +
+    " check its return value, assert side-effects.";
+/**
+ * Creates ESLint rules that ban `expect(typeof <expr>).<matcher>(...)` patterns.
+ *
+ * These assertions only verify that JavaScript knows the type of an expression
+ * at the time the test runs — information that TypeScript already guarantees at
+ * compile time. They are a classic AI-generated coverage-padding anti-pattern.
+ *
+ * ❌ FORBIDDEN:
+ * ```typescript
+ * expect(typeof tabula.close).toBe("function");
+ * expect(typeof result).toBe("object");
+ * expect(typeof user.name).toEqual("string");
+ * ```
+ *
+ * ✅ CORRECT: test observable behaviour
+ * ```typescript
+ * // Call the function and assert what it does
+ * await tabula.close();
+ * expect(tabula.isClosed()).toBe(true);
+ *
+ * // Assert the shape of a result
+ * expect(result).toMatchObject({ id: expect.any(String) });
+ *
+ * // Assert the value, not the type
+ * expect(user.name).toBe("Alice");
+ * ```
+ * @returns ESLint rules that prevent typeof-in-expect patterns
+ */
+export function createNoTypeofInExpectRules() {
+    return {
+        "no-restricted-syntax": [
+            "error",
+            {
+                selector: TYPEOF_IN_EXPECT_SELECTOR,
+                message: NO_TYPEOF_IN_EXPECT_MESSAGE,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=test-quality.js.map

package/dist/src/custom-rules/type-safety.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Type safety rule definitions for ReasonableTech projects
+ *
+ * These rules prevent type system bypasses and enforce safe type handling
+ * patterns, particularly around Result types and type assertions.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+import type { Linter } from "eslint";
+/**
+ * Configuration options for type safety rules
+ */
+export interface TypeSafetyRuleOptions {
+    /** Base URL for documentation references */
+    docBaseUrl?: string;
+    /** Whether to allow type assertions in test files (default: false) */
+    allowInTests?: boolean;
+}
+/**
+ * Custom ESLint rule that prevents `as any` and `<any>` type casts
+ *
+ * This rule detects all forms of casting to `any`, including:
+ * - `expr as any`
+ * - `<any>expr`
+ * - Double casts through any: `(expr as any) as T`
+ *
+ * Each variant produces a distinct, descriptive error message rather than the
+ * generic "no-restricted-syntax" label that the previous AST-selector approach
+ * showed in editors.
+ */
+export declare const noAsAnyRule: ESLintUtils.RuleModule<"asAny" | "angleAny" | "doubleCast", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+/**
+ * Creates rules that prevent `as any` type casts
+ *
+ * These rules block the use of `as any` type assertions, which bypass
+ * TypeScript's type checking and create type safety holes.
+ *
+ * ❌ FORBIDDEN:
+ * ```typescript
+ * const data = response as any; // Bypasses type checking
+ * const x = (response as any) as User; // Double cast through any
+ * ```
+ *
+ * ✅ CORRECT:
+ * ```typescript
+ * const data = parseResponse(response); // Proper typed parsing
+ * const user = data.result.user; // Type-safe access
+ * ```
+ * @param _options Configuration options for type safety rules (reserved for future use)
+ * @returns ESLint rules that prevent `as any` casts
+ */
+export declare function createNoAnyRules(_options?: TypeSafetyRuleOptions): Linter.RulesRecord;
+/**
+ * Creates a complete set of type safety rules
+ *
+ * This is the main function that combines all type safety rules
+ * into a single configuration object.
+ * @param options Configuration options for type safety rules
+ * @returns Complete set of type safety ESLint rules
+ */
+export declare function createTypeSafetyRules(options?: TypeSafetyRuleOptions): Linter.RulesRecord;
+/**
+ * Preset for Platform-specific type safety rules
+ *
+ * This preset provides all type safety rules configured specifically
+ * for platform project conventions and documentation structure.
+ * @returns ESLint rules configured for platform projects
+ */
+export declare function createPlatformTypeSafetyRules(): Linter.RulesRecord;
+//# sourceMappingURL=type-safety.d.ts.map