TypeScript Import Type Helpers

In TypeScript, when dealing with complex module structures, it's common to need to extract specific types from imported modules. This challenge focuses on creating robust utility types that simplify the process of obtaining and manipulating types imported from other modules. This is particularly useful for maintaining cleaner type definitions and reducing boilerplate when working with external libraries or internal modules.

Problem Description

Your task is to implement a set of TypeScript utility types that help in extracting types from imported modules. You will need to create type helpers that can:

1. Extract a specific named export as a type.
2. Extract a default export as a type.
3. Extract all named exports as a single object type.
4. Extract all exports (default and named) as a single object type.

You should aim to make these types generic and reusable.

Key Requirements:

• ImportNamed<Module, Name>: A type that takes a module (represented as an imported namespace) and a string literal Name representing the name of a named export. It should return the type of that named export.
• ImportDefault<Module>: A type that takes a module (represented as an imported namespace) and returns the type of its default export.
• ImportAllNamed<Module>: A type that takes a module and returns an object type where each key is a named export from the module, and its value is the corresponding type.
• ImportAll<Module>: A type that takes a module and returns an object type containing all exports (both default and named). The default export should be accessible under a specific key (e.g., 'default').

Expected Behavior:

The types should correctly infer and provide the types of the exports from a given module, as if you had directly imported them.

Edge Cases:

• Modules with no named exports.
• Modules with no default export.
• Modules with both default and named exports.
• Handling the case where a named export doesn't exist (this might result in never or an error, depending on how you implement it; a graceful failure is preferred).

Examples

Let's assume we have a module my-module.ts with the following content:

// my-module.ts
export type SomeType = { a: number };
export interface AnotherType { b: string };
export const someValue = 123;

export default class MyClass {
    greet() { return "Hello!"; }
}

And we import it in another file like so:

// another-file.ts
import * as MyModule from './my-module';

Example 1: Extracting a Named Export

// Input:
type ExtractedType = ImportNamed<typeof MyModule, 'SomeType'>;

// Output:
// type ExtractedType = { a: number; }

Example 2: Extracting the Default Export

// Input:
type ExtractedDefault = ImportDefault<typeof MyModule>;

// Output:
// type ExtractedDefault = MyClass;

Example 3: Extracting All Named Exports

// Input:
type AllNamed = ImportAllNamed<typeof MyModule>;

// Output:
// type AllNamed = {
//     SomeType: { a: number; };
//     AnotherType: { b: string; };
//     someValue: number;
// }

Example 4: Extracting All Exports

// Input:
type AllExports = ImportAll<typeof MyModule>;

// Output:
// type AllExports = {
//     default: MyClass;
//     SomeType: { a: number; };
//     AnotherType: { b: string; };
//     someValue: number;
// }

Constraints

• The solution must be implemented purely in TypeScript.
• The utility types should be generic and work with any module imported using import * as ModuleName from '...'.
• Assume that the typeof ModuleName correctly represents the module's namespace object.
• No runtime code is required; this is a type-level programming challenge.

Notes

• Consider how TypeScript's keyof operator and mapped types can be useful here.
• You might need to think about how default exports are represented in the module namespace object.
• For ImportNamed, how would you handle cases where the Name does not exist as an export? TypeScript's conditional types or intersection with never could be relevant.
• For ImportAll, you'll need a way to specifically identify and include the default export alongside named exports.