TypeScript Destructured Variable

interface Payload {
  code: number;
  message: string;
  timestamp: string;
}

const response: Payload = { code: 200, message: "OK", timestamp: "2023-10-01" };

// Inferred typing: 'code' is number, 'message' is string
const { code, message } = response;

// This renames the 'code' property to a new variable named 'responseCode'.
// TypeScript correctly infers the variable 'responseCode' as type 'number'.
const { code: responseCode } = response; 

// To apply explicit types while renaming, the type annotation must follow the entire destructuring pattern.
const { code: statusCode, message: msg }: { code: number; message: string } = response;

// Tuple destructuring
const matrix: [number, string, boolean] = [1, "active", true];

// TypeScript strictly types 'id' as number, 'status' as string
const [id, status] = matrix;

// Skipping elements maintains correct positional typing ('flag' is boolean)
const [, , flag] = matrix;

interface Config {
  timeout?: number;
  retries?: number;
}

const settings: Config = { timeout: 5000 };

// 'retries' is typed as 'number' (not 'number | undefined') due to the default value
const { timeout, retries = 3 }: Config = settings;

// Object Rest
const { timestamp, ...coreData } = response;
// coreData is typed as: { code: number; message: string; }

// Array Rest
const sequence: number[] = [10, 20, 30, 40];
const [head, ...tail] = sequence;
// tail is typed as: number[]

// Destructuring with an external interface
function initialize({ timeout, retries }: Config): void {
  // Implementation
}

// Destructuring with inline typing
function updateCoordinates([x, y]: [number, number]): void {
  // Implementation
}