How to fix Exported variable 'X' has or is using name 'Y' from external module 'Z' but cannot be named in TypeScript

// BEFORE - Type is inferred, causes TS4023
import { DataGrid } from '@mui/x-data-grid';

export const myGrid = DataGrid({ /* config */ });
// Error: Exported variable 'myGrid' has or is using name 'DataGridComponent'

// AFTER - Explicitly typed
import { DataGrid, DataGridProps } from '@mui/x-data-grid';

export const myGrid: React.ComponentType<DataGridProps> = DataGrid({ /* config */ });

// BEFORE
import { someFunction } from 'external-lib';

export const config = {
  handler: someFunction(),
  options: { /* ... */ }
};

// AFTER
import { someFunction, HandlerType } from 'external-lib';

interface ConfigType {
  handler: HandlerType;
  options: { /* ... */ };
}

export const config: ConfigType = {
  handler: someFunction(),
  options: { /* ... */ }
};

// Error message says:
// "has or is using name 'NumberKeywords' from external module 'ajv/dist/types/json-schema'"

// BEFORE - Type used but not imported
import Ajv from 'ajv';

export const validator = new Ajv();

// AFTER - Import the type explicitly
import Ajv from 'ajv';
import type { NumberKeywords } from 'ajv/dist/types/json-schema';

export const validator = new Ajv();

import type { SomeType } from 'external-module';
import { someFunction } from 'external-module';

export const result: ReturnType<typeof someFunction> = someFunction();

// BEFORE - Re-exporting without types
export { default as MyComponent } from 'external-lib';

// AFTER - Explicit type export
export type { ComponentProps } from 'external-lib';
export { default as MyComponent } from 'external-lib';

// BEFORE
import * as Utils from './utils';
export const helpers = Utils;

// AFTER
export type * as Utils from './utils';
export * from './utils';

// OR with explicit namespace
import type * as UtilsType from './utils';
import * as UtilsImpl from './utils';

export const helpers: typeof UtilsType = UtilsImpl;

// external-lib/index.ts
// BEFORE - InternalConfig not exported
interface InternalConfig {
  setting: string;
}

export function createHandler(config: InternalConfig) {
  return { /* ... */ };
}

// AFTER - Export all types used in public API
export interface InternalConfig {
  setting: string;
}

export function createHandler(config: InternalConfig) {
  return { /* ... */ };
}

import { createHandler } from 'external-lib';
import type { InternalConfig } from 'external-lib';

export const handler: ReturnType<typeof createHandler> = createHandler({
  setting: 'value'
});

# Check your TypeScript version
npx tsc --version

# Update to latest TypeScript
npm install --save-dev typescript@latest

# Or specific version (5.x recommended)
npm install --save-dev typescript@^5.0.0

// Your source code
import { Hash } from 'crypto';
export const hash = createHash('sha256');

// Generated declaration (TypeScript 2.9+)
export declare const hash: import("crypto").Hash;

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "esnext",
    "moduleResolution": "bundler",
    "declaration": true
  }
}

// BEFORE
import { createComplexObject } from 'external-lib';

export const instance = createComplexObject({ /* config */ });

// AFTER - Using ReturnType
import { createComplexObject } from 'external-lib';

export const instance: ReturnType<typeof createComplexObject> =
  createComplexObject({ /* config */ });

// BEFORE
import { SomeClass } from 'external-lib';

export const instance = new SomeClass();

// AFTER - Using InstanceType
import { SomeClass } from 'external-lib';

export const instance: InstanceType<typeof SomeClass> = new SomeClass();

import { processData } from 'external-lib';

type ProcessedData = {
  result: string;
  metadata: Record<string, unknown>;
};

export const data: ProcessedData = processData(input);