Non-exported classes in type declaration files leaking value names

Reproduza o comportamento usando os exemplos de classes.d.ts, test.js e test.ts na issue e, em seguida, rastreie a resolução de módulos e símbolos de arquivos de declaração no TypeScript compiler. A tarefa estará concluída quando a classe A não exportada não for exposta como um valor, enquanto as referências de tipo exigidas pela classe B exportada continuarem sendo resolvidas, com cobertura de regressão para ambos os exemplos.

TypeScript Version: 3.5.2

Search Terms: ambient module declaration export declare class type name

Code

In a file called classes.d.ts:

declare class A {}
export declare class B extends A {}

In a file called test.js:

let a = require('classes').A;

In a file called test.ts:

import { A } from './types/classes';

[NEW] Assumptions:
The following is a list of assumptions I had when originally opening this issue:

1. Type Declaration Files work like modules: once you use import or export [on a top-level declaration], only explicitly exported declarations are visible externally.
2. Type names declared in a Declaration File are always accessible via import types (at least those that are used by exported types.
   • E.g. export class B extends A exports the type names A and B, even if A was not directly exported.
3. Value names declared in a module-style Declaration File (see #1 above) are only accessible if explicitly exported.

These assumptions are the result of reading the documentation and working with declaration files. Note that the documentation does not mention:

1. All declarations in a declaration file are implicitly exported.
2. Special [and undocumented?] export {}; syntax causes only explicitly exported declarations to be available by consumers of the declaration file.

I list them here to provide context for the Expected Behavior section.

Expected behavior:
In both cases , an Error that name 'A' could be found in module 'classes'.

I expect in this case that TypeScript is capable of resolving the following from the declaration file:

1. The Value "B".
2. The Types "A" and "B".

In other words, I should be able to use import types to resolve class A, but attempts to use them should fail.

Actual behavior:
No compiler error in either case. TypeScript-powered IDEs (e.g. VSCode) happily show that the full non-exported class A is available.

In short, a non-exported, declared class should resolve in the same way as an interface.

As things stand today, TypeScript erroneously resolves the Value "A".

Playground Link: NA

Related Issues: NA