# microsoft/typescript-handbook

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/microsoft-typescript-handbook).**

4,855 stars · 1,109 forks · JavaScript · Apache-2.0 · archived

## Links

- GitHub: https://github.com/microsoft/TypeScript-Handbook
- Homepage: https://github.com/microsoft/TypeScript-Website
- awesome-repositories: https://awesome-repositories.com/repository/microsoft-typescript-handbook.md

## Topics

`documentation` `learn` `typescript` `typescript-handbook`

## Description

This project is a comprehensive guide and educational resource for the TypeScript language. It covers the fundamental principles of the language, including its structural type system, static type analysis, and the process of transpiling typed source files into JavaScript.

The material details how to model complex data and reusable type logic using generics, conditional types, and mapped types. It also explains the use of declaration files to provide type safety for external JavaScript libraries and the integration of type checking into existing JavaScript projects via JSDoc annotations.

The scope of the content extends to object-oriented programming patterns, DOM manipulation, and the configuration of compiler behaviors. It includes guidance on managing module interoperability, setting up build pipelines, and utilizing editor intelligence for better developer productivity.

## Tags

### Education & Learning Resources

- [TypeScript Learning Paths](https://awesome-repositories.com/f/education-learning-resources/javascript-learning-resources/typescript-learning-paths.md) — Serves as a comprehensive educational resource for learning TypeScript syntax and its type system.

### Data & Databases

- [Type-Based Data Modeling](https://awesome-repositories.com/f/data-databases/complex-data-types/type-based-data-modeling.md) — Provides techniques for creating reusable structures and shorthand aliases to model complex data shapes. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html))
- [Literal Types](https://awesome-repositories.com/f/data-databases/data-type-definitions/scalar-types/custom-scalars/scalar-value-generation/literal-value-definitions/literal-types.md) — Explains how to limit variables or parameters to specific constant string or numeric values. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [External Library Type Mappings](https://awesome-repositories.com/f/data-databases/data-type-mappings/system-type-mappings/declarative-type-mapping-layers/external-library-type-mappings.md) — Covers the use of declaration files to provide type safety for external JavaScript libraries.
- [Optional Property Declarations](https://awesome-repositories.com/f/data-databases/object-property-accessors/collection-property-modifiers/graph-property-modifiers/optional-property-access/optional-property-declarations.md) — Explains the syntax for declaring optional properties in object types to make them non-mandatory. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))

### Development Tools & Productivity

- [Compiler Configurations](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-orchestration-logic/build-orchestration-configuration/build-configuration-systems/compiler-configurations.md) — Provides detailed configuration of compiler behavior and module resolution via JSON settings. ([source](https://www.typescriptlang.org/docs/handbook/compiler-options-in-msbuild.html))
- [Static Code Analyzers](https://awesome-repositories.com/f/development-tools-productivity/code-quality-analysis/static-analysis-engines/static-analysis-tools/static-code-analyzers.md) — Provides instructions on using static analysis to identify potential errors and bugs before program execution. ([source](https://www.typescriptlang.org/docs/handbook/2/basic-types.html))
- [TypeScript Configurations](https://awesome-repositories.com/f/development-tools-productivity/project-scaffolding-config-code-generation/project-scaffolding-configuration/build-configuration/typescript-configurations.md) — Covers the configuration of the TypeScript compiler and build pipelines to target specific JavaScript environments.
- [Strictness Levels](https://awesome-repositories.com/f/development-tools-productivity/static-analysis-configurations/strictness-levels.md) — Allows adjustment of type validation strictness to balance leniency with rigorous error checking. ([source](https://www.typescriptlang.org/docs/handbook/2/basic-types.html))
- [Compilation Pipelines](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-orchestration-logic/build-orchestration-configuration/build-lifecycle-orchestrators/compilation-pipelines.md) — Describes how to orchestrate the transformation of source code into browser-ready assets via compilation pipelines. ([source](https://www.typescriptlang.org/docs/handbook/gulp.html))
- [Generic Type Defaults](https://awesome-repositories.com/f/development-tools-productivity/configuration-defaults/generic-type-defaults.md) — Explains how to provide fallback types for generic parameters to make them optional for consumers. ([source](https://www.typescriptlang.org/docs/handbook/2/generics.html))
- [Editor Productivity Enhancements](https://awesome-repositories.com/f/development-tools-productivity/editor-productivity-enhancements.md) — Leverages the type system to provide auto-complete, jump-to-symbol, and refactoring capabilities within JavaScript editors. ([source](https://www.typescriptlang.org/docs/handbook/intro-to-js-ts.html))
- [Declaration Generation](https://awesome-repositories.com/f/development-tools-productivity/javascript-and-typescript-build-systems/javascript-to-typescript-migration/declaration-generation.md) — Explains how to generate type declaration files from JavaScript using JSDoc to enable type-powered editor experiences. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/dts-from-js.html))
- [Code Intelligence Providers](https://awesome-repositories.com/f/development-tools-productivity/prompt-information-providers/code-intelligence-providers.md) — Enables real-time code completion and navigation by providing semantic code intelligence based on type information. ([source](https://www.typescriptlang.org/docs/handbook/2/basic-types.html))

### Programming Languages & Runtimes

- [Ambient Type Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/ambient-type-declarations.md) — Teaches how to write declaration files using API patterns to enable type-checking for JavaScript libraries. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html))
- [TypeScript Transpilers](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/typescript-transpilers.md) — Explains the high-speed transpilation of TypeScript source files into plain JavaScript. ([source](https://www.typescriptlang.org/docs/handbook/babel-with-typescript.html))
- [Conditional Types](https://awesome-repositories.com/f/programming-languages-runtimes/dependent-type-systems/conditional-types.md) — Explains how to use conditional types to determine resulting types based on input assignability. ([source](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html))
- [Function Signature Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/function-definitions/recursive-type-definitions/typed-function-declarations/function-signature-declarations.md) — Teaches how to define function types and overloads to ensure type-safe imports. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-function-d-ts.html))
- [Function Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/function-overloading.md) — Guides the specification of multiple valid signatures for a single function to support varied input and output types. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html))
- [Function Signatures](https://awesome-repositories.com/f/programming-languages-runtimes/function-signatures.md) — Details the specification of input parameters and return types to ensure function type safety. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [Function Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/function-type-definitions.md) — Provides detailed methods for specifying expected parameters and return types for functions. ([source](https://www.typescriptlang.org/docs/handbook/2/functions.html))
- [Generic Classes](https://awesome-repositories.com/f/programming-languages-runtimes/generic-classes.md) — Teaches how to create classes with type parameters for flexible, type-safe instantiation. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Generic Components](https://awesome-repositories.com/f/programming-languages-runtimes/generic-components.md) — Details the creation of functions, interfaces, or classes that maintain type precision across various input types. ([source](https://www.typescriptlang.org/docs/handbook/2/generics.html))
- [Generic Types](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types.md) — Provides comprehensive guidance on using type parameters to create reusable functions, classes, and types. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Generic Functions](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/generic-functions.md) — Explains how to establish type correspondence between input and output values using type parameters in functions. ([source](https://www.typescriptlang.org/docs/handbook/2/functions.html))
- [Generic Type Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/generic-type-constraints.md) — Explains how to restrict type parameters to types that satisfy a specific shape for compile-time safety. ([source](https://www.typescriptlang.org/docs/handbook/2/generics.html))
- [Conditional Type Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/generic-type-constraints/conditional-type-constraints.md) — Covers the narrowing of generic types within specific logical branches to ensure required properties. ([source](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html))
- [Type Parameter Inference](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/type-parameter-inference.md) — Explains how the compiler automatically infers generic type arguments based on provided values. ([source](https://www.typescriptlang.org/docs/handbook/2/generics.html))
- [Interfaces](https://awesome-repositories.com/f/programming-languages-runtimes/interfaces.md) — Explains how to define interfaces to enforce object shapes and structural type safety. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [JavaScript Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/javascript-compilers.md) — Transforms high-level typed source code into executable JavaScript. ([source](https://www.typescriptlang.org/docs/handbook/2/basic-types.html))
- [JavaScript Module Type Signatures](https://awesome-repositories.com/f/programming-languages-runtimes/javascript-module-validation/javascript-module-type-signatures.md) — Guides the creation of type signatures for JavaScript codebases using CommonJS and ES Module patterns. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html))
- [JavaScript Static Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/javascript-static-analysis.md) — Guides users on validating standard JavaScript files for type errors using configuration files and JSDoc. ([source](https://www.typescriptlang.org/docs/handbook/intro-to-js-ts.html))
- [Source-to-JavaScript Transpilers](https://awesome-repositories.com/f/programming-languages-runtimes/javascript-transpilers/source-to-javascript-transpilers.md) — Provides guidance on converting typed TypeScript source files into plain JavaScript for runtime compatibility.
- [Discriminated Unions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/union-types/discriminated-unions.md) — Explains how to use tagged unions to differentiate between members of a union type for safe runtime access. ([source](https://www.typescriptlang.org/docs/handbook/2/narrowing.html))
- [External Library Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/external-type-definition-overrides/external-library-definitions.md) — Describes how to use ambient declarations to map the shapes of external JavaScript libraries for type safety. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html))
- [Generic Containers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/generic-containers.md) — Describes how to define data structures using type parameters to hold varying types safely. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Type Aliases](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/type-aliases.md) — Provides instructions for creating reusable named aliases for complex or frequently used type definitions. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Type Narrowing](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing.md) — Describes how to refine variable types through runtime checks and control-flow analysis.
- [Explicit Variable Typing](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/explicit-variable-typing.md) — Teaches the use of type annotations to specify expected data shapes for variables and function arguments. ([source](https://www.typescriptlang.org/docs/handbook/2/basic-types.html))
- [Module Export and Import Systems](https://awesome-repositories.com/f/programming-languages-runtimes/module-export-and-import-systems.md) — Provides comprehensive guidance on sharing variables, functions, and types using ES module and CommonJS patterns. ([source](https://www.typescriptlang.org/docs/handbook/2/modules.html))
- [Module Organization](https://awesome-repositories.com/f/programming-languages-runtimes/module-organization.md) — Guides the organization of code into reusable modules and manages interoperability between different module systems. ([source](https://www.typescriptlang.org/docs/))
- [Module Output Customizations](https://awesome-repositories.com/f/programming-languages-runtimes/module-output-customizations.md) — Explains how to configure the JavaScript version and module format of emitted code for runtime compatibility. ([source](https://www.typescriptlang.org/docs/handbook/2/modules.html))
- [Nullability Handling](https://awesome-repositories.com/f/programming-languages-runtimes/nullability-handling.md) — Teaches how to handle absent values using strict null checks and non-null assertion operators. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [Object Key Extractors](https://awesome-repositories.com/f/programming-languages-runtimes/object-key-extractors.md) — Explains how to generate a union of literal keys from an object type using the keyof operator. ([source](https://www.typescriptlang.org/docs/handbook/2/keyof-types.html))
- [Object Type Transformations](https://awesome-repositories.com/f/programming-languages-runtimes/object-type-transformations.md) — Details how to modify property names during type transformation using template literals and conditional types. ([source](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html))
- [Primitive Types](https://awesome-repositories.com/f/programming-languages-runtimes/primitive-types.md) — Covers the use of basic built-in primitive types like string, number, and boolean for type safety. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [JSDoc Type Checking](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/type-checking-disciplines/typed-javascript-alternatives/jsdoc-type-checking.md) — Details the integration of type safety into existing JavaScript projects using JSDoc annotations and declaration files. ([source](https://www.typescriptlang.org/docs/))
- [Conditional Types](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/conditional-types.md) — Details the use of conditional types to evaluate types against logical conditions during the compilation process.
- [Declaration Merging](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/declaration-files/declaration-merging.md) — Covers declaration merging, allowing multiple declarations of the same name to be combined into one entity. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/deep-dive.html))
- [Source Code Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers.md) — Provides the core capability of transforming TypeScript source code into JavaScript. ([source](https://www.typescriptlang.org/docs/handbook/compiler-options.html))
- [Static Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/static-type-definitions.md) — Demonstrates how to assign specific data types to variables and functions to catch errors during development. ([source](https://www.typescriptlang.org/docs/))
- [String Literal Type Manipulations](https://awesome-repositories.com/f/programming-languages-runtimes/string-literal-type-manipulations.md) — Details how to automate type definitions using conditional types, mapped types, and template literals. ([source](https://www.typescriptlang.org/docs/))
- [Structural Class Compatibility](https://awesome-repositories.com/f/programming-languages-runtimes/structural-class-compatibility.md) — Explains how the type system determines compatibility between classes based on their members rather than names. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Third Party Library Typing](https://awesome-repositories.com/f/programming-languages-runtimes/third-party-library-typing.md) — Provides instructions on integrating third-party type declarations via package managers for external library analysis. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html))
- [Type Assertions](https://awesome-repositories.com/f/programming-languages-runtimes/type-assertions.md) — Provides techniques for overriding inferred types when the developer has specific knowledge of a value's type. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [Type Casting](https://awesome-repositories.com/f/programming-languages-runtimes/type-casting.md) — Demonstrates how to force a value to be treated as a specific type via type tags. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Type Checking Bypasses](https://awesome-repositories.com/f/programming-languages-runtimes/type-checking-bypasses.md) — Explains the use of special types to disable compiler errors for specific values. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [Type Declaration Files](https://awesome-repositories.com/f/programming-languages-runtimes/type-declaration-files.md) — Provides comprehensive guidance on writing declaration files to enable type safety for external JavaScript dependencies. ([source](https://www.typescriptlang.org/docs/))
- [Type Declaration Specification](https://awesome-repositories.com/f/programming-languages-runtimes/type-declaration-specification.md) — Describes how to specify valid types and signatures for JavaScript code using declaration files. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html))
- [Type Inference from Values](https://awesome-repositories.com/f/programming-languages-runtimes/type-inference-from-values.md) — Teaches how to extract type information from existing values to ensure consistency between data and types. ([source](https://www.typescriptlang.org/docs/handbook/2/types-from-types.html))
- [Type Checking](https://awesome-repositories.com/f/programming-languages-runtimes/type-relationship-verification/type-checking.md) — Covers the process of verifying if a value satisfies a specific type during compilation. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Union Types](https://awesome-repositories.com/f/programming-languages-runtimes/union-types.md) — Covers combining multiple types into one to represent a value that may be any of the specified members. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [User-Defined Types](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types.md) — Details the construction of custom types, interfaces, and generics to enforce data shapes. ([source](https://www.typescriptlang.org/docs/))
- [External Library Type Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types/complex-module-type-definitions/external-library-type-declarations.md) — Explains how to create type definitions for JavaScript libraries via global variables, modular imports, or UMD patterns. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html))
- [Object Type Composition](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types/object-type-composition.md) — Provides instructions on using interfaces and intersections to compose and extend object types. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Object Types](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types/object-types.md) — Explains how to specify required properties and types for objects using various declaration methods. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Type Aliases](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types/type-aliases.md) — Provides guidance on creating shorthand names for complex types to improve code maintainability. ([source](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html))
- [Class Inheritance](https://awesome-repositories.com/f/programming-languages-runtimes/class-inheritance.md) — Covers extending base classes to derive new classes that inherit all parent properties and methods. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Generic Base Class Extension](https://awesome-repositories.com/f/programming-languages-runtimes/class-inheritance/generic-base-class-extension.md) — Demonstrates how to pass type arguments to a base class when inheriting from a generic parent. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Class Member Access](https://awesome-repositories.com/f/programming-languages-runtimes/class-member-access.md) — Covers the use of visibility modifiers to define public, private, and protected class properties. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Static Methods](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-definitions/static-methods.md) — Describes how to define properties and methods that belong to the class constructor rather than instances. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Class Method Overrides](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-overrides.md) — Guides the explicit identification of methods that replace implementations from a base class. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Static This-Context Typing](https://awesome-repositories.com/f/programming-languages-runtimes/function-context-management/static-this-context-typing.md) — Shows how to statically enforce the calling context using explicit this parameters and arrow functions. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Incremental Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/incremental-compilation.md) — Describes the incremental compilation model that re-compiles only affected parts of a project to speed up development.
- [Index Signatures](https://awesome-repositories.com/f/programming-languages-runtimes/index-signatures.md) — Describes how to use index signatures to define objects with unknown property names. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Interface Contract Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/interface-contract-implementations.md) — Describes using the implements clause to ensure a class satisfies a specific interface contract. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Module Resolvers](https://awesome-repositories.com/f/programming-languages-runtimes/language-ecosystems-tooling/module-management/module-resolution/module-resolvers.md) — Details the use of configurable lookup engines to resolve import strings to actual files using various strategies. ([source](https://www.typescriptlang.org/docs/handbook/2/modules.html))
- [CommonJS-ESM Interoperability](https://awesome-repositories.com/f/programming-languages-runtimes/language-ecosystems-tooling/module-management/module-resolution/module-resolvers/commonjs-resolvers/commonjs-esm-interoperability.md) — Covers the interoperability between different module systems like ESM and CommonJS. ([source](https://www.typescriptlang.org/docs/))
- [Downlevel Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/javascript-language-features/modern-syntax/downlevel-compilers.md) — Explains the process of rewriting modern language features into older JavaScript versions for legacy environment support.
- [Exhaustiveness Checks](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/union-types/discriminated-unions/exhaustiveness-checks.md) — Demonstrates how to use the never type to ensure all members of a discriminated union are handled. ([source](https://www.typescriptlang.org/docs/handbook/2/narrowing.html))
- [Excess Property Checks](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/object-property-descriptors/property-definers/excess-property-checks.md) — Explains excess property checking to identify bugs when passing extra properties to typed object literals. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Type-Only Imports](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/ambient-type-declarations/type-only-imports.md) — Describes how to import type signatures without adding runtime code or triggering module resolution. ([source](https://www.typescriptlang.org/docs/handbook/2/modules.html))
- [Cross-Package Type Imports](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/ambient-type-declarations/type-only-imports/cross-package-type-imports.md) — Guides the management of required type definition packages via package metadata. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html))
- [Namespace-Type Merging](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/type-aliases/namespace-type-merging.md) — Explains how to create a single declaration that possesses properties of both a namespace and another type. ([source](https://www.typescriptlang.org/docs/handbook/declaration-merging.html))
- [Type Namespace Organization](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/type-aliases/type-namespace-organization.md) — Shows how to group related types and values into logical hierarchies using dotted notation to prevent global scope pollution. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/by-example.html))
- [Namespace Merging](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/type-aliases/type-namespace-organization/namespace-merging.md) — Describes how to join multiple namespaces with the same name to combine their exported members. ([source](https://www.typescriptlang.org/docs/handbook/declaration-merging.html))
- [Fixed Length Array Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/array-declaration-styles/fixed-length-declarations/fixed-length-array-definitions.md) — Guides the use of tuple types to specify arrays with a fixed length and specific element types. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [Custom Type Guards](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing/custom-type-guards.md) — Provides instructions on creating user-defined functions with type predicates for manual type narrowing. ([source](https://www.typescriptlang.org/docs/handbook/2/narrowing.html))
- [This-Based Type Guards](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing/this-based-type-guards.md) — Details how to use this-based type guards in method return types to narrow instance types in conditional blocks. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Constructor Parameter Properties](https://awesome-repositories.com/f/programming-languages-runtimes/primary-constructors/constructor-parameter-properties.md) — Provides guidance on using parameter properties to automatically create and assign class fields via visibility modifiers. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Read-Only Properties](https://awesome-repositories.com/f/programming-languages-runtimes/primary-constructors/constructor-parameter-properties/read-only-properties.md) — Explains the syntax for declaring class properties that cannot be reassigned after their initial assignment. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Type Declaration Registries](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/typescript-declaration-tooling/declaration-file-providers/type-declaration-registries.md) — Describes how to map JavaScript packages to type definition files for distribution to consumers. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html))
- [Global Type Augmentations](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/typescript-declaration-tooling/global-type-augmentations.md) — Explains how to extend the global namespace with custom type definitions to support libraries that modify built-in prototypes.
- [Ambient Module Augmentations](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/typescript-declaration-tooling/global-type-augmentations/dual-module-declarations/ambient-module-augmentations.md) — Explains type definition patterns for extending third-party library signatures using declaration files. ([source](https://www.typescriptlang.org/docs/handbook/declaration-merging.html))
- [Abstract Classes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/abstract-classes.md) — Explains the creation of base classes that lack implementations to force derived classes to provide logic. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Declaration Files](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/declaration-files.md) — Explains how to mirror a JavaScript library's directory structure within declaration files to support deep imports. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html))
- [Type Component Extraction](https://awesome-repositories.com/f/programming-languages-runtimes/static-type-inference/type-inference-support/component-type-inferences/type-component-extraction.md) — Covers advanced type manipulation using the infer keyword to extract return types or element types. ([source](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html))
- [String Literal Construction](https://awesome-repositories.com/f/programming-languages-runtimes/string-literal-type-manipulations/string-literal-construction.md) — Details how to create new string literal types by combining concrete strings or unions. ([source](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html))
- [Template Literal Types](https://awesome-repositories.com/f/programming-languages-runtimes/template-literal-types.md) — Explains the use of template literal types for string interpolation and pattern validation at compile time. ([source](https://www.typescriptlang.org/docs/handbook/2/types-from-types.html))
- [Class Member Annotations](https://awesome-repositories.com/f/programming-languages-runtimes/type-annotations/class-member-annotations.md) — Details how to define class properties and methods with type annotations and read-only modifiers. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))
- [Decorator Annotations](https://awesome-repositories.com/f/programming-languages-runtimes/type-annotations/type-annotations/decorator-annotations.md) — Covers attaching decorators to classes and members to modify or observe their definitions at runtime. ([source](https://www.typescriptlang.org/docs/handbook/decorators.html))
- [Custom Decorator Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/type-annotations/type-annotations/decorator-annotations/custom-decorator-definitions.md) — Details the use of decorator factories to pass custom arguments and configure decorator behavior. ([source](https://www.typescriptlang.org/docs/handbook/decorators.html))
- [Distributive Conditional Types](https://awesome-repositories.com/f/programming-languages-runtimes/union-type-transformations/distributive-conditional-types.md) — Covers how conditional types distribute over unions to enable advanced type mapping. ([source](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html))
- [Complex Module Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/user-defined-types/complex-module-type-definitions.md) — Teaches how to create custom types and generics within declaration files for rich JavaScript API type information. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html))

### Security & Cryptography

- [Static Type Error Detectors](https://awesome-repositories.com/f/security-cryptography/injection-prevention/reliability-prevention-patterns/logical-error-prevention/static-type-error-detectors.md) — Implements static analysis to identify type errors and structural incompatibilities without executing the program.
- [Member Visibility Control](https://awesome-repositories.com/f/security-cryptography/identity-access-management/access-control/encapsulation-modifiers/member-visibility-control.md) — Guides the use of public, protected, and private modifiers to encapsulate internals from external code. ([source](https://www.typescriptlang.org/docs/handbook/2/classes.html))

### Software Engineering & Architecture

- [TypeScript Advanced Type Features](https://awesome-repositories.com/f/software-engineering-architecture/advanced-type-systems/typescript-advanced-type-features.md) — Guides the design of complex data structures using advanced features like generics, conditional types, and mapped types.
- [Type Transformations](https://awesome-repositories.com/f/software-engineering-architecture/advanced-type-systems/typescript-advanced-type-features/type-transformations.md) — Covers the use of mapped types to create new types by iterating over and transforming an existing type's keys. ([source](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html))
- [Declaration Merging](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations/module-functionality-extenders/declaration-merging.md) — Explains how to add new members to existing interfaces or classes by declaring another interface with the same name. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/deep-dive.html))
- [Mapped Type Transformations](https://awesome-repositories.com/f/software-engineering-architecture/mapped-type-transformations.md) — Describes the use of mapped types to iterate over keys and transform object structures. ([source](https://www.typescriptlang.org/docs/handbook/2/types-from-types.html))
- [JSDoc Type Annotations](https://awesome-repositories.com/f/software-engineering-architecture/static-type-checking/jsdoc-type-annotations.md) — Enables static type checking of standard JavaScript files using JSDoc annotations. ([source](https://www.typescriptlang.org/docs/))
- [Automated Type Generation](https://awesome-repositories.com/f/software-engineering-architecture/type-safe-development/automated-type-generation.md) — Supports the automatic generation of .d.ts files from source code to provide static type information. ([source](https://www.typescriptlang.org/docs/handbook/compiler-options.html))
- [Structural Typing and Inference](https://awesome-repositories.com/f/software-engineering-architecture/type-systems/structural-typing-and-inference.md) — Provides a comprehensive guide to TypeScript's structural type system where compatibility is based on object shape.
- [Advanced Type Transformations](https://awesome-repositories.com/f/software-engineering-architecture/typescript-type-definitions/schema-driven-type-inference/schema-type-inference/complex-type-resolution/advanced-type-transformations.md) — Provides a guide to modeling complex data using conditional and mapped type transformations. ([source](https://www.typescriptlang.org/docs/))
- [Static Type Checking](https://awesome-repositories.com/f/software-engineering-architecture/typescript-type-definitions/static-type-checking.md) — Details how to perform static type checking to verify consistency and generate declaration files. ([source](https://www.typescriptlang.org/docs/handbook/babel-with-typescript.html))
- [Optional Parameter Markers](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation/data-type-validation/parameter-type-enforcement/optional-parameter-markers.md) — Explains how to mark function parameters as optional or provide default values for flexible API design. ([source](https://www.typescriptlang.org/docs/handbook/2/functions.html))
- [Decorator Composition](https://awesome-repositories.com/f/software-engineering-architecture/decorator-patterns/decorators/decorator-composition.md) — Explains how to apply multiple decorators to a single declaration and the order of their execution. ([source](https://www.typescriptlang.org/docs/handbook/decorators.html))
- [Decorator Metadata Emission](https://awesome-repositories.com/f/software-engineering-architecture/metadata-attachments/type-associated-metadata/decorator-metadata-emission.md) — Describes emitting design-time type metadata for decorated declarations to support runtime reflection. ([source](https://www.typescriptlang.org/docs/handbook/decorators.html))
- [Template Literal Types](https://awesome-repositories.com/f/software-engineering-architecture/string-manipulators/string-manipulation-types/template-literal-types.md) — Explains how to derive and constrain types using string patterns and template literals. ([source](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html))
- [Constant Enums](https://awesome-repositories.com/f/software-engineering-architecture/type-safe-constants/constant-enums.md) — Details the use of constant enumerations to improve performance by inlining values at compile time. ([source](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html))
- [Object Property Type Extractors](https://awesome-repositories.com/f/software-engineering-architecture/typescript-type-definitions/static-type-checking/type-specifications/array-element/object-property-type-extractors.md) — Explains how to extract specific property types from an object using keyof operators and indexed access types. ([source](https://www.typescriptlang.org/docs/handbook/2/indexed-access-types.html))

### Web Development

- [Intersection Types](https://awesome-repositories.com/f/web-development/graphql-apis/type-definitions/union-types/intersection-types.md) — Describes how to combine multiple types into a single type that requires all members using intersection operators. ([source](https://www.typescriptlang.org/docs/handbook/2/objects.html))
- [DOM Element Typing](https://awesome-repositories.com/f/web-development/dom-element-manipulators/dom-element-typing.md) — Provides instructions on applying strict TypeScript types to HTML and SVG elements for safer DOM manipulation. ([source](https://www.typescriptlang.org/docs/handbook/dom-manipulation.html))
- [JSX Transformers](https://awesome-repositories.com/f/web-development/jsx-transformers.md) — Details the transformation of JSX syntax into standard JavaScript function calls. ([source](https://www.typescriptlang.org/docs/handbook/jsx.html))
- [JSX Type Definitions](https://awesome-repositories.com/f/web-development/jsx-type-definitions.md) — Explains how to customize the expected return types of JSX expressions and components via interface overrides. ([source](https://www.typescriptlang.org/docs/handbook/jsx.html))

### DevOps & Infrastructure

- [Dependency Declarations](https://awesome-repositories.com/f/devops-infrastructure/dependency-management/configuration-declaration-formats/dependency-declarations.md) — Provides guidance on using directives and import statements to declare external library dependencies for correct type resolution. ([source](https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html))
- [Module Interoperability](https://awesome-repositories.com/f/devops-infrastructure/deployment-management-strategies/execution-platforms-and-targets/deployment-targets/node-js-runtimes/module-interoperability.md) — Explains how to bridge the functional gap and ensure compatibility between CommonJS and ES module systems. ([source](https://www.typescriptlang.org/docs/handbook/2/modules.html))

### Part of an Awesome List

- [Programming Languages](https://awesome-repositories.com/f/awesome-lists/devtools/programming-languages.md) — Official documentation for language features and usage.
- [Learning Resources](https://awesome-repositories.com/f/awesome-lists/learning/learning-resources.md) — The official comprehensive guide for learning language syntax and features.