How to fix Default export of the module has or is using private name 'X' in TypeScript

What this error means

The "Default export of the module has or is using private name" error (TS4082) appears when TypeScript's declaration file generator encounters a default export that references a type, interface, or class that is not publicly exported from the module. This happens specifically when you have declaration file generation enabled (via "declaration": true in tsconfig.json). TypeScript's declaration emitter needs to serialize all types used in public exports into .d.ts files that other developers can use. When it encounters a private type in an export signature, it cannot safely emit that type because: 1. The type isn't imported/exported in the declaration file 2. Adding automatic imports would expose implementation details the developer didn't intend to make public 3. The resulting declaration file would be invalid or incomplete This error is particularly common in: - Vue components using `defineProps<Props>()` where Props isn't exported - Default exports of functions/classes that use internal types in their signatures - Libraries attempting to export functionality that depends on private types - Projects using frameworks that generate type definitions at build time

Typical symptoms

• Build fails with error code TS4082 when generating declaration files
• Error message mentions 'has or is using private name' followed by a type name
• Compilation succeeds when 'declaration' is set to false in tsconfig.json
• IDE shows error on default export statement
• Error appears when building a library or package for distribution
• Issue occurs in Vue components with defineProps using unexported interface
• Rollup or webpack builds fail during type generation phase

Common causes

1. Interface or type used in default export is not explicitly exported from the module
2. Class or function signature references a private type as parameter or return value
3. Vue component uses defineProps with an unexported Props interface
4. Default export references types from dependencies without re-exporting them
5. Declaration file generation is enabled but internal types are exposed in public API
6. Third-party library type definitions contain private type references
7. Build configuration includes test or story files in type declaration generation

How to fix "Default export of the module has or is using private name 'X'"

// BEFORE - Causes TS4082 error
interface Props {
  name: string;
  age: number;
}

export default defineComponent({
  props: defineProps<Props>()
});

// AFTER - Fixed by exporting Props
export interface Props {
  name: string;
  age: number;
}

export default defineComponent({
  props: defineProps<Props>()
});

// BEFORE - Error when building library
interface ButtonProps {
  variant: 'primary' | 'secondary';
  onClick: () => void;
}

export default function Button(props: ButtonProps) {
  return <button onClick={props.onClick}>{props.children}</button>;
}

// AFTER - Fixed
export interface ButtonProps {
  variant: 'primary' | 'secondary';
  onClick: () => void;
}

export default function Button(props: ButtonProps) {
  return <button onClick={props.onClick}>{props.children}</button>;
}

// Instead of a separate interface
interface Props {
  title: string;
  count: number;
}
export default defineProps<Props>();

// Use inline type definition
export default defineProps<{
  title: string;
  count: number;
}>();

// BEFORE - Private Config type
interface Config {
  apiKey: string;
  timeout: number;
}

export default function initialize(config: Config) {
  // ...
}

// AFTER - Inline type
export default function initialize(config: {
  apiKey: string;
  timeout: number;
}) {
  // ...
}

{
  "compilerOptions": {
    "declaration": true
  },
  "include": ["src/**/*"],
  "exclude": [
    "node_modules",
    "**/*.test.ts",
    "**/*.spec.ts",
    "**/*.stories.ts",
    "**/__tests__/**"
  ]
}

// rollup.config.js
import typescript from '@rollup/plugin-typescript';

export default {
  plugins: [
    typescript({
      exclude: [
        '**/*.test.ts',
        '**/*.spec.ts',
        '**/*.stories.tsx',
        'src/__tests__/**'
      ]
    })
  ]
};

// BEFORE - Private Test class leaks into export
class Test {
  constructor(private value: string) {}
}

export const instance = new Test("value");
// Error: Exported variable 'instance' has or is using private name 'Test'

// AFTER - Explicit 'any' type annotation
export const instance: any = new Test("value");

// BETTER - Define a public interface
export interface Instance {
  getValue(): string;
}

class Test implements Instance {
  constructor(private value: string) {}
  getValue() { return this.value; }
}

export const instance: Instance = new Test("value");

// Private internal type
type InternalResult = {
  _internal: string;
  data: string;
};

// Hide implementation details with explicit return type
export default function process(): { data: string } {
  const result: InternalResult = {
    _internal: "secret",
    data: "public"
  };
  return result;
}

// BEFORE - Default export with private type
interface ComponentProps {
  title: string;
}

export default function Component(props: ComponentProps) {
  return <div>{props.title}</div>;
}

// AFTER - Named exports (recommended)
export interface ComponentProps {
  title: string;
}

export function Component(props: ComponentProps) {
  return <div>{props.title}</div>;
}

import Component from './Component';

import { Component } from './Component';

// tsconfig.json
{
  "compilerOptions": {
    "declaration": false,
    // Or temporarily:
    // "declaration": true,
    // "declarationMap": false
  }
}

Advanced notes

interface InternalConfig {
  secret: string;
}

export default function init(config: InternalConfig) {
  // ...
}

// Would be invalid - InternalConfig is not exported!
export default function init(config: InternalConfig): void;

// Problematic pattern
interface Props {
  msg: string;
}

export default defineComponent({
  setup() {
    const props = defineProps<Props>();
  }
});

export interface Props {
  msg: string;
}

const props = defineProps<{
  msg: string;
}>();

const props = defineProps({
  msg: { type: String, required: true }
});

// src/index.ts
export { Button, type ButtonProps } from './Button';
export { Input, type InputProps } from './Input';
// Don't export internal utilities

// Your code
import { SomeFunction } from 'third-party-lib';

export default SomeFunction;
// Error: Default export uses private name from 'third-party-lib'

import { SomeFunction } from 'third-party-lib';

export default function wrapped(...args: any[]): any {
  return SomeFunction(...args);
}

// packages/shared/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true
  }
}

// packages/shared/src/index.ts
// Export all types that dependent packages might need
export interface Config { ... }
export type Status = 'active' | 'inactive';

# Generate declarations and inspect output
npx tsc --declaration --emitDeclarationOnly --outDir dist-types

# Review the generated .d.ts files
cat dist-types/yourfile.d.ts

Frequently asked questions

What does "TS4082" mean?

The "Default export of the module has or is using private name" error (TS4082) appears when TypeScript's declaration file generator encounters a default export that references a type, interface, or class that is not publicly exported from the module. json). ts files that other developers can use.

How do I fix "TS4082"?

This TypeScript error occurs when generating declaration files (.d.ts) for code that exports a type or interface that hasn't been explicitly exported from the module. The compiler cannot create valid type declarations when the default export references private (unexported) types.

What causes "TS4082"?

Interface or type used in default export is not explicitly exported from the module Class or function signature references a private type as parameter or return value Vue component uses defineProps with an unexported Props interface

Is the "TS4082" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Default type of constructor property must be assignable to its declared type

  How to fix "Default type of constructor property must be assignable to its declared type" in TypeScript

  MEDIUM

• Decorators are not valid on parameters unless 'emitDecoratorMetadata' is enabled

  Decorators are not valid on parameters unless 'emitDecoratorMetadata' is enabled

  MEDIUM

• All destructured elements are unused

  All destructured elements are unused

  LOW

• Decorators are not valid here

  How to fix 'Decorators are not valid here' error in TypeScript

  MEDIUM

• Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.

  How to fix "Cannot find name 'process'" in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• 🐙
  TypeScript Issue #36076 - Default export private name discussion(GitHub)
• 🐙
  TypeScript Issue #55635 - TS4082 error reports(GitHub)
• 🐙
  Vue Language Tools - Default export private name in Vue components(GitHub)
• 🐙
  Storybook Issue #12064 - Private name error in Stories(GitHub)
• Lightrun - Fixing private name error in Volar
• 📖
  TypeScript Handbook - Declaration Files(Official Docs)
• 📖
  TypeScript TSConfig - declaration option(Official Docs)
• TypeScript Deep Dive - Avoid Export Default