> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # TypeScript Async Method An asynchronous method in TypeScript is a class or object member declared with the `async` modifier, which instructs the compiler to implicitly wrap the method's return value in a `Promise`. It enables the use of the `await` keyword within the method's lexical scope to pause execution until a given `Promise` settles, allowing asynchronous control flow to be written in a synchronous style. ## Syntax and Type Signatures In TypeScript, the return type of an `async` method must always be a `Promise`, where `T` represents the type of the resolved value. If the method does not return a value, TypeScript's type inference engine will automatically infer the return type as `Promise`, though it may still be explicitly typed for strictness or readability. ```typescript theme={"dark"} class DataController { // Method returning a resolved value of type 'string' public async retrieveRecord(id: number): Promise { // Using Promise.resolve to simulate an asynchronous operation const recordName = await Promise.resolve(`Record_${id}`); return recordName; } // Method returning no value; TypeScript infers Promise private async executeTask() { await this.retrieveRecord(1); } } ``` ## Technical Mechanics * **Type Enforcement:** TypeScript's static analyzer enforces that an `async` method cannot declare a raw return type (e.g., `string`). Declaring `public async getData(): string` will result in a compiler error (`TS1064: The return type of an async function or method must be the global Promise type`). * **Execution Context:** When an `async` method is invoked, it executes synchronously until it encounters the first `await` expression. At that point, the method yields control back to the calling execution context. The remainder of the method is queued as a microtask to resume once the awaited `Promise` resolves or rejects. * **Error Propagation:** Any exception thrown within the body of an `async` method—whether synchronous or resulting from a rejected `await` expression—is automatically caught and returned as a rejected `Promise`. ## Interface Implementation When defining a TypeScript `interface` or `type` alias for a class containing asynchronous methods, the `async` keyword is omitted. The `async` modifier is strictly an implementation detail, whereas the interface defines the structural contract (the `Promise` return type). ```typescript theme={"dark"} // Contract definition interface IDataController { retrieveRecord(id: number): Promise; } // Implementation class PostgresController implements IDataController { // The async modifier is applied here, satisfying the Promise contract public async retrieveRecord(id: number): Promise { return "record_data"; } } ``` ## Object Literal Methods The `async` modifier can also be applied to methods defined within object literals. The type inference and return type rules remain identical to class methods. ```typescript theme={"dark"} const service = { status: 'idle', async initialize(): Promise { this.status = 'running'; return true; } }; ```

Tired of Poor TypeScript Skills? Fix That With Deep Grasping! Learn More