Types

All types are exported from @t-req/core and subpath exports.

Core Types

From @t-req/core

import type {
  // Parsing
  ParsedRequest,
  FileReference,
  FormField,

  // Interpolation
  InterpolateOptions,
  Interpolator,
  Resolver,

  // Execution
  ExecuteRequest,
  ExecuteOptions,

  // Client
  Client,
  ClientConfig,
  RunOptions,

  // File loading
  FileLoaderOptions,
  LoadedFile,

  // Form data building
  BuildFormDataOptions,
} from '@t-req/core';

Parsing Types

ParsedRequest

interface ParsedRequest {
  name?: string;
  method: string;
  url: string;
  headers: Record<string, string>;
  body?: string;
  formData?: FormField[];
  bodyFile?: FileReference;
  raw: string;
  meta: Record<string, string>;
}

FormField

interface FormField {
  name: string;
  value: string;
  isFile: boolean;
  path?: string;
  filename?: string;
}

FileReference

interface FileReference {
  path: string;
  filename?: string;
}

Client Types

Client

interface Client {
  run(path: string, options?: RunOptions): Promise<Response>;
  runString(content: string, options?: RunOptions): Promise<Response>;
  setVariable(key: string, value: unknown): void;
  setVariables(variables: Record<string, unknown>): void;
  getVariables(): Record<string, unknown>;
}

ClientConfig

interface ClientConfig {
  io?: IO;
  transport?: Transport;
  variables?: Record<string, unknown>;
  resolvers?: Record<string, Resolver>;
  cookieJar?: CookieJar;
  timeout?: number;
  defaults?: RequestDefaults;
}

RunOptions

interface RunOptions {
  variables?: Record<string, unknown>;
  timeout?: number;
  signal?: AbortSignal;
}

RequestDefaults

interface RequestDefaults {
  headers?: Record<string, string>;
  followRedirects?: boolean;
  validateSSL?: boolean;
}

Interpolation Types

Resolver

type Resolver = (...args: string[]) => string | Promise<string>;

Interpolator

interface Interpolator {
  interpolate(
    template: string,
    variables: Record<string, unknown>
  ): Promise<string>;
}

InterpolateOptions

interface InterpolateOptions {
  resolvers?: Record<string, Resolver>;
  undefinedBehavior?: 'throw' | 'keep' | 'empty';
}

Execution Types

ExecuteRequest

interface ExecuteRequest {
  method: string;
  url: string;
  headers: Record<string, string>;
  body?: string | Uint8Array | FormData;
  timeout?: number;
  signal?: AbortSignal;
}

Runtime Types

From @t-req/core/runtime

import type { IO, Transport } from '@t-req/core/runtime';

IO

interface IO {
  readFile(path: string): Promise<string>;
  readBinaryFile(path: string): Promise<Uint8Array>;
  resolvePath(base: string, relative: string): string;
}

Transport

interface Transport {
  execute(request: ExecuteRequest): Promise<Response>;
}

Cookie Types

From @t-req/core/cookies

import type { Cookie, CookieJar } from '@t-req/core/cookies';

Cookie

interface Cookie {
  key: string;
  value: string;
  domain: string;
  path: string;
  expires?: Date;
  httpOnly: boolean;
  secure: boolean;
  sameSite?: string;
  creation: Date;
  lastAccessed: Date;
}

Config Types

From @t-req/core/config

import type {
  TReqConfig,
  ConfigDefaults,
  LoadConfigOptions,
  LoadConfigResult,
} from '@t-req/core/config';

TReqConfig

interface TReqConfig {
  variables?: Record<string, unknown>;
  resolvers?: Record<string, Resolver>;
  defaults?: ConfigDefaults;
}

ConfigDefaults

interface ConfigDefaults {
  timeoutMs?: number;
  headers?: Record<string, string>;
  followRedirects?: boolean;
  validateSSL?: boolean;
}

Engine Types

From @t-req/core

import type {
  Engine,
  EngineConfig,
  EngineEvent,
} from '@t-req/core';

EngineEvent

type EngineEvent =
  | RequestStartEvent
  | RequestCompleteEvent
  | RequestErrorEvent;

interface RequestStartEvent {
  type: 'request:start';
  request: ExecuteRequest;
  timestamp: number;
}

interface RequestCompleteEvent {
  type: 'request:complete';
  request: ExecuteRequest;
  response: Response;
  duration: number;
  timestamp: number;
}

interface RequestErrorEvent {
  type: 'request:error';
  request?: ExecuteRequest;
  error: Error;
  timestamp: number;
}

Type Helpers

Generic Response Data

async function getJson<T>(response: Response): Promise<T> {
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`);
  }
  return response.json() as Promise<T>;
}

// Usage
interface User {
  id: number;
  name: string;
}

const user = await getJson<User>(response);

Typed Variables

interface MyVariables {
  baseUrl: string;
  token: string;
  userId: number;
}

const client = createClient({
  variables: {
    baseUrl: 'https://api.example.com',
    token: 'secret',
    userId: 123,
  } satisfies MyVariables,
});