Repository: TypeScript
Issue: Accumulating type in TypeScript like powerful instrument for organizing code
Labels: Suggestion,In Discussion

## Main Idea
Accumulating type is a type that combines the types of declarations that occur in different parts of the code with the same name. Type merging is done according to the OR principle.
Principles and dogmas:
 * related code in one place
 * organizing separate and independent modules
 * write once use everywhere
 * intermodular interaction through types

## Search Terms
accumulate type, type system

## Suggestion
Add the ability to declare **accumulative** types

## Examples
```typescrypt
// file: moduleAFolder/moduleA.ts
    accumulate type ModuleNames = "ModuleA"; // type to be "ModuleA" | "ModuleB"
    
// file: moduleAFolder/moduleAHelper.ts
    import {ModuleNames} from "moduleAFolder/moduleA";
    //      ^ powerful part of example: importing type ONLY from moduleA, NOT from ModuleB
    //      ^ accessible value for ModuleNames here are "ModuleA" and "ModuleB"

    const a: ModuleNames = "ModuleA"; // it's ok
    const b: ModuleNames = "ModuleB"; // it's ok.
    const c: ModuleNames = "Unknown"; // it's error
    
// file: moduleBFolder/moduleB.ts
    accumulate type ModuleNames = "ModuleB"; // type to be "ModuleA" | "ModuleB";                   
```
Example above is very simple but illustrates all principles good code. In more difficalt cases we have 100 modules and 1000 types. Some of them has types that need in another modules.

Yes, we can create folder with name 'shared' and move common types to this folder:
 * but then we destroy the integrity of the code inside the separate module. Everything that looked whole before that became fragmented;
 * but then we make the “shared” folder a trash or garbage;

Yes, we can copy common types from one module to another:
 * but then we make smelling bad code;
 * but then we make bug prone code;

## More difficult example
```typescrypt
 // file: moduleAFolder/moduleA.ts
     accumulate type CrossModuleTypes = {
         "ModuleA": {
             id: string;
             data: {
                 value: string;
             }
         }
     }
     
     
 // file: moduleBFolder/moduleB.ts
     accumulate type CrossModuleTypes = {
         "ModuleB": {
             id: string;
             segment: {
                 part: string;
             }
         }
     }
     
 // file: moduleCFolder/moduleC.ts
     // no imports here!
     accumulate type CrossModuleTypes; // nothing merge, only usaging;
     type UnionToIntersection<U> =  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
     type ModuleBType = UnionToIntersection<CrossModuleTypes>["ModuleB"];
     const cachingData: ModuleBType = this.loadFromCache("ModuleB");
     console.log("Caching segment from ModuleB is ", cachingData.segment.part); // no errors here.
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).