callman-core 1.35.0 → 1.36.0

package/dist-cjs/script/pm-api-declarations.js

@@ -0,0 +1,1969 @@
+"use strict";
+// Authoritative TypeScript declaration text for the script sandbox.
+//
+// Editors (Monaco `addExtraLib`) feed `getPmApiDeclarations(...)` to their TS
+// worker so autocomplete, hover and diagnostics describe EXACTLY what the
+// runtime exposes. The file is browser-safe on purpose: strings only, no
+// imports, no Node APIs.
+//
+// Conventions
+//   • The editor is assumed to use `lib: ["es2022"]` WITHOUT `dom`, so every web
+//     global the sandbox provides (console, URL, TextEncoder, crypto, …) is
+//     declared here, with the types the SANDBOX has — not the DOM's.
+//   • `pm`, `cm` and `callman` are the same object.
+//   • `pm.response.json()` returns `CallmanResponseBody`, declared in a SEPARATE
+//     chunk (CALLMAN_RESPONSE_BODY_DECLARATION) so an editor can replace it with
+//     a type inferred from the last response body. getPmApiDeclarations() does
+//     NOT contain it — always add one of the two.
+//   • The runtime is the source of truth. `scripts/check-pm-api-drift.mjs`
+//     reflects the real sandbox objects and fails CI when PM_API_DECLARED_MEMBERS
+//     (and therefore these declarations) fall behind.
+//
+// When the sandbox gains or loses a member, update the declaration AND
+// PM_API_DECLARED_MEMBERS in the same commit.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_API_DECLARED_MEMBERS = exports.getScenarioLabelDeclarations = exports.getPmApiDeclarationLibs = exports.getPmApiDeclarations = exports.PM_API_RESERVED_NAMES = exports.PM_REQUIRABLE_MODULE_ALIASES = exports.PM_REQUIRABLE_MODULES = exports.CALLMAN_RESPONSE_BODY_DECLARATION_PATH = exports.PM_API_DECLARATIONS_PATH = exports.CALLMAN_RESPONSE_BODY_DECLARATION = void 0;
+/** Default type of `pm.response.json()`. Editors replace this chunk with a type inferred from a sample body. */
+exports.CALLMAN_RESPONSE_BODY_DECLARATION = "type CallmanResponseBody = any;";
+/** Virtual file paths editors can use for the two chunks. */
+exports.PM_API_DECLARATIONS_PATH = "file:///callman/pm-api.d.ts";
+exports.CALLMAN_RESPONSE_BODY_DECLARATION_PATH = "file:///callman/response-body.d.ts";
+/** Modules `require()` / `pm.require()` can load (mirrors postman/modules.ts). */
+exports.PM_REQUIRABLE_MODULES = [
+    "lodash",
+    "moment",
+    "chai",
+    "ajv",
+    "cheerio",
+    "xml2js",
+    "tv4",
+    "uuid",
+    "csv-parse/lib/sync",
+    "postman-collection",
+    "crypto-js",
+    "atob",
+    "btoa",
+    "path",
+    "assert",
+    "buffer",
+    "util",
+    "url",
+    "querystring",
+    "string_decoder",
+    "stream",
+    "events",
+    "punycode",
+    "timers",
+];
+/** Alternative spellings accepted by the runtime (resolved to the module above). */
+exports.PM_REQUIRABLE_MODULE_ALIASES = {
+    "string-decoder": "string_decoder",
+    "csv-parse/sync": "csv-parse/lib/sync",
+    "csv-parse": "csv-parse/lib/sync",
+};
+/**
+ * Names a scenario node label can NOT use as a global (mirrors RESERVED_LABEL_NAMES
+ * in scope.ts; the drift check keeps the two equal).
+ */
+exports.PM_API_RESERVED_NAMES = [
+    "AbortController", "AbortSignal", "AggregateError", "Array", "ArrayBuffer", "BigInt", "BigInt64Array",
+    "BigUint64Array", "Blob", "Boolean", "Buffer", "DOMException", "DataView", "Date", "Error", "EvalError",
+    "Event", "EventTarget", "File", "FinalizationRegistry", "Float32Array", "Float64Array", "Function",
+    "Infinity", "Int16Array", "Int32Array", "Int8Array", "Intl", "JSON", "Map", "Math", "NaN", "Number",
+    "Object", "Promise", "Proxy", "RangeError", "ReadableStream", "ReferenceError", "Reflect", "RegExp",
+    "Set", "String", "Symbol", "SyntaxError", "TextDecoder", "TextDecoderStream", "TextEncoder",
+    "TextEncoderStream", "TransformStream", "TypeError", "URIError", "URL", "URLSearchParams", "Uint16Array",
+    "Uint32Array", "Uint8Array", "Uint8ClampedArray", "WeakMap", "WeakRef", "WeakSet", "WebSocket", "Worker",
+    "WritableStream", "XMLHttpRequest", "atob", "btoa", "callman", "cm", "console", "crypto", "db",
+    "decodeURI", "decodeURIComponent", "document", "encodeURI", "encodeURIComponent", "env", "escape",
+    "eval", "expect", "exports", "fetch", "global", "globalThis", "importScripts", "isFinite", "isNaN",
+    "kafka", "module", "navigator", "parseFloat", "parseInt", "pm", "postman", "process", "queueMicrotask",
+    "redis", "request", "require", "response", "self", "structuredClone", "test", "undefined", "unescape",
+    "window", "workflow",
+];
+// ───────────────────────────────────────────────────────────────────────────
+// Web / Node globals the sandbox provides (lib es2022 has none of them)
+// ───────────────────────────────────────────────────────────────────────────
+const PLATFORM_GLOBALS = `
+interface ScriptConsole {
+  /** Print to the script console (also: info, warn, error, debug). Supports %s %d %i %f %j %o %O %c. */
+  log(...data: any[]): void;
+  info(...data: any[]): void;
+  warn(...data: any[]): void;
+  error(...data: any[]): void;
+  debug(...data: any[]): void;
+  /** Log with a stack trace. */
+  trace(...data: any[]): void;
+  /** Log an error when the condition is falsy. */
+  assert(condition?: any, ...data: any[]): void;
+  count(label?: string): void;
+  countReset(label?: string): void;
+  time(label?: string): void;
+  timeLog(label?: string, ...data: any[]): void;
+  timeEnd(label?: string): void;
+  /** Indent following output until groupEnd(). */
+  group(...label: any[]): void;
+  groupCollapsed(...label: any[]): void;
+  groupEnd(): void;
+  /** Render an array of objects / arrays as a table. */
+  table(data: any, columns?: string[]): void;
+  dir(item?: any, options?: any): void;
+  dirxml(...data: any[]): void;
+  /** Clear the console buffer of the host. */
+  clear(): void;
+}
+declare const console: ScriptConsole;
+
+declare function atob(data: string): string;
+declare function btoa(data: string): string;
+declare function structuredClone<T>(value: T, options?: { transfer?: any[] }): T;
+declare function queueMicrotask(callback: () => void): void;
+
+/** Timers are per-run wrappers: delays are capped at 60 s and everything pending is cancelled when the script ends. */
+declare function setTimeout(handler: (...args: any[]) => void, delay?: number, ...args: any[]): number;
+declare function clearTimeout(id: number | undefined): void;
+declare function setInterval(handler: (...args: any[]) => void, delay?: number, ...args: any[]): number;
+declare function clearInterval(id: number | undefined): void;
+declare function setImmediate(handler: (...args: any[]) => void, ...args: any[]): number;
+declare function clearImmediate(id: number | undefined): void;
+
+declare class TextEncoder {
+  readonly encoding: string;
+  encode(input?: string): Uint8Array;
+  encodeInto(source: string, destination: Uint8Array): { read: number; written: number };
+}
+declare class TextDecoder {
+  constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+  decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string;
+}
+
+declare class URLSearchParams implements Iterable<[string, string]> {
+  constructor(init?: string | string[][] | Record<string, string> | URLSearchParams);
+  readonly size: number;
+  append(name: string, value: string): void;
+  delete(name: string, value?: string): void;
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string, value?: string): boolean;
+  set(name: string, value: string): void;
+  sort(): void;
+  forEach(callback: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  toString(): string;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+declare class URL {
+  constructor(url: string | URL, base?: string | URL);
+  static canParse(url: string, base?: string): boolean;
+  hash: string;
+  host: string;
+  hostname: string;
+  href: string;
+  readonly origin: string;
+  password: string;
+  pathname: string;
+  port: string;
+  protocol: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  username: string;
+  toString(): string;
+  toJSON(): string;
+}
+
+declare class Event {
+  constructor(type: string, init?: { bubbles?: boolean; cancelable?: boolean; composed?: boolean });
+  readonly type: string;
+  readonly defaultPrevented: boolean;
+  preventDefault(): void;
+  stopPropagation(): void;
+}
+declare class EventTarget {
+  addEventListener(type: string, listener: ((event: any) => void) | { handleEvent(event: any): void } | null, options?: boolean | { once?: boolean; passive?: boolean; signal?: AbortSignal }): void;
+  removeEventListener(type: string, listener: ((event: any) => void) | { handleEvent(event: any): void } | null, options?: boolean | { capture?: boolean }): void;
+  dispatchEvent(event: Event): boolean;
+}
+declare class DOMException extends Error {
+  constructor(message?: string, name?: string);
+  readonly code: number;
+}
+declare class AbortSignal extends EventTarget {
+  static abort(reason?: any): AbortSignal;
+  static timeout(milliseconds: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
+  readonly aborted: boolean;
+  readonly reason: any;
+  onabort: ((event: Event) => void) | null;
+  throwIfAborted(): void;
+}
+declare class AbortController {
+  readonly signal: AbortSignal;
+  abort(reason?: any): void;
+}
+declare class Blob {
+  constructor(blobParts?: Array<string | ArrayBuffer | ArrayBufferView | Blob>, options?: { type?: string; endings?: "transparent" | "native" });
+  readonly size: number;
+  readonly type: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  slice(start?: number, end?: number, contentType?: string): Blob;
+  stream(): ReadableStream<Uint8Array>;
+}
+declare class File extends Blob {
+  constructor(fileBits: Array<string | ArrayBuffer | ArrayBufferView | Blob>, fileName: string, options?: { type?: string; lastModified?: number });
+  readonly name: string;
+  readonly lastModified: number;
+}
+declare class ReadableStream<R = any> {
+  constructor(underlyingSource?: any, strategy?: any);
+  readonly locked: boolean;
+  cancel(reason?: any): Promise<void>;
+  getReader(): { read(): Promise<{ done: boolean; value?: R }>; releaseLock(): void; cancel(reason?: any): Promise<void>; closed: Promise<void> };
+  pipeThrough<T>(transform: { readable: ReadableStream<T>; writable: WritableStream<R> }, options?: any): ReadableStream<T>;
+  pipeTo(destination: WritableStream<R>, options?: any): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+}
+declare class WritableStream<W = any> {
+  constructor(underlyingSink?: any, strategy?: any);
+  readonly locked: boolean;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): { write(chunk?: W): Promise<void>; close(): Promise<void>; abort(reason?: any): Promise<void>; releaseLock(): void; closed: Promise<void>; ready: Promise<void> };
+}
+declare class TransformStream<I = any, O = any> {
+  constructor(transformer?: any, writableStrategy?: any, readableStrategy?: any);
+  readonly readable: ReadableStream<O>;
+  readonly writable: WritableStream<I>;
+}
+declare class TextEncoderStream {
+  readonly encoding: string;
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<string>;
+}
+declare class TextDecoderStream {
+  constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+  readonly encoding: string;
+  readonly readable: ReadableStream<string>;
+  readonly writable: WritableStream<ArrayBuffer | ArrayBufferView>;
+}
+
+type PmBufferEncoding = "utf8" | "utf-8" | "hex" | "base64" | "base64url" | "ascii" | "latin1" | "binary" | "ucs2" | "ucs-2" | "utf16le" | "utf-16le";
+interface Buffer extends Uint8Array {
+  toString(encoding?: PmBufferEncoding, start?: number, end?: number): string;
+  toJSON(): { type: "Buffer"; data: number[] };
+  equals(other: Uint8Array): boolean;
+  compare(other: Uint8Array): -1 | 0 | 1;
+  write(value: string, offset?: number, length?: number, encoding?: PmBufferEncoding): number;
+  copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+  indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: PmBufferEncoding): number;
+  includes(value: string | number | Uint8Array, byteOffset?: number, encoding?: PmBufferEncoding): boolean;
+  readUInt8(offset?: number): number;
+  readUInt16BE(offset?: number): number;
+  readUInt16LE(offset?: number): number;
+  readUInt32BE(offset?: number): number;
+  readUInt32LE(offset?: number): number;
+  readInt8(offset?: number): number;
+  readInt16BE(offset?: number): number;
+  readInt16LE(offset?: number): number;
+  readInt32BE(offset?: number): number;
+  readInt32LE(offset?: number): number;
+  writeUInt8(value: number, offset?: number): number;
+  writeUInt16BE(value: number, offset?: number): number;
+  writeUInt16LE(value: number, offset?: number): number;
+  writeUInt32BE(value: number, offset?: number): number;
+  writeUInt32LE(value: number, offset?: number): number;
+}
+interface PmBufferConstructor {
+  readonly prototype: Buffer;
+  from(data: string, encoding?: PmBufferEncoding): Buffer;
+  from(data: ArrayBuffer | ArrayLike<number> | Iterable<number>, byteOffset?: number, length?: number): Buffer;
+  alloc(size: number, fill?: string | number | Uint8Array, encoding?: PmBufferEncoding): Buffer;
+  allocUnsafe(size: number): Buffer;
+  concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
+  isBuffer(value: any): value is Buffer;
+  isEncoding(encoding: string): boolean;
+  byteLength(value: string | ArrayBuffer | ArrayBufferView, encoding?: PmBufferEncoding): number;
+  compare(a: Uint8Array, b: Uint8Array): -1 | 0 | 1;
+}
+declare const Buffer: PmBufferConstructor;
+
+interface PmCryptoKey {
+  readonly type: "secret" | "private" | "public";
+  readonly extractable: boolean;
+  readonly algorithm: { name: string; [option: string]: any };
+  readonly usages: string[];
+}
+interface PmSubtleCrypto {
+  digest(algorithm: string | { name: string }, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+  importKey(format: string, keyData: any, algorithm: any, extractable: boolean, keyUsages: string[]): Promise<PmCryptoKey>;
+  exportKey(format: string, key: PmCryptoKey): Promise<any>;
+  generateKey(algorithm: any, extractable: boolean, keyUsages: string[]): Promise<PmCryptoKey | { publicKey: PmCryptoKey; privateKey: PmCryptoKey }>;
+  sign(algorithm: any, key: PmCryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+  verify(algorithm: any, key: PmCryptoKey, signature: ArrayBuffer | ArrayBufferView, data: ArrayBuffer | ArrayBufferView): Promise<boolean>;
+  encrypt(algorithm: any, key: PmCryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+  decrypt(algorithm: any, key: PmCryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+  deriveBits(algorithm: any, baseKey: PmCryptoKey, length: number): Promise<ArrayBuffer>;
+  deriveKey(algorithm: any, baseKey: PmCryptoKey, derivedKeyType: any, extractable: boolean, keyUsages: string[]): Promise<PmCryptoKey>;
+}
+interface PmWebCrypto {
+  readonly subtle: PmSubtleCrypto;
+  getRandomValues<T extends ArrayBufferView | null>(array: T): T;
+  randomUUID(): string;
+}
+declare const crypto: PmWebCrypto;
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// postman-collection object model (pm.request / pm.response / cookies)
+// ───────────────────────────────────────────────────────────────────────────
+const SDK_TYPES = `
+interface PmPropertyBase {
+  /** Free-form metadata (rarely used). */
+  meta?: any;
+  readonly parent: any;
+  setParent(parent: any): void;
+  findInParents(property: string, customizer?: (item: any) => boolean): any;
+  findParentContaining(item: any, customizer?: (item: any) => boolean): any;
+  forEachParent(options: { withRoot?: boolean } | ((parent: any) => void), iterator?: (parent: any) => void): void;
+  toJSON(): any;
+}
+interface PmProperty extends PmPropertyBase {
+  id?: string;
+  name?: string;
+  disabled?: boolean;
+  describe(content: string, type?: string): void;
+  findSubstitutions(): string[];
+  toObjectResolved(variables?: any, overrides?: any, options?: { ignoreOwnVariables?: boolean }): any;
+}
+
+/** postman-collection PropertyList: an ordered collection with Postman's lookup / mutation helpers. */
+interface PmPropertyList<T> extends PmPropertyBase {
+  readonly Type: any;
+  /** The items as an array. */
+  readonly members: T[];
+  /** Items keyed by their index key (header name, query key, …). */
+  readonly reference: Record<string, T>;
+  add(item: T | object): void;
+  append(item: T | object): void;
+  prepend(item: T | object): void;
+  insert(item: T | object, before?: T | string): void;
+  insertAfter(item: T | object, after?: T | string): void;
+  upsert(item: T | object): boolean | null;
+  assimilate(source: PmPropertyList<T> | Array<T | object>, prune?: boolean): void;
+  populate(items: Array<T | object>): void;
+  repopulate(items: Array<T | object>): void;
+  clear(): void;
+  count(): number;
+  idx(index: number): T | undefined;
+  indexOf(item: T | string): number;
+  one(id: string): T | undefined;
+  get(key: string): any;
+  has(item: T | string, value?: any): boolean;
+  all(): T[];
+  each(iterator: (item: T, index: number) => void, context?: any): void;
+  eachParent(iterator: (parent: any) => void, context?: any): void;
+  map<R>(iterator: (item: T, index: number) => R, context?: any): R[];
+  filter(rule: (item: T, index: number) => boolean, context?: any): T[];
+  find(rule: (item: T, index: number) => boolean, context?: any): T | undefined;
+  reduce<R>(iterator: (accumulator: R, item: T, index: number) => R, accumulator: R, context?: any): R;
+  remove(predicate: T | string | ((item: T) => boolean), context?: any): void;
+  toObject(excludeDisabled?: boolean, caseSensitive?: boolean, multiValue?: boolean, sanitizeKeys?: boolean): Record<string, any>;
+  toString(): string;
+}
+
+interface PmHeader extends PmProperty {
+  key: string;
+  value: string;
+  system?: boolean;
+  update(header: string | { key?: string; value?: string }): void;
+  toString(): string;
+  valueOf(): string;
+}
+/** Header collection. Besides Postman's list API, bracket access reads / writes a header by name (case-insensitive). */
+interface PmHeaderList extends PmPropertyList<PmHeader> {
+  /** Case-insensitive value lookup. */
+  get(name: string): string | undefined;
+  /** Total size of the headers in bytes. */
+  contentSize(): number;
+  [name: string]: any;
+}
+interface PmQueryParam extends PmProperty {
+  key: string | null;
+  value: string | null;
+  system?: boolean;
+  update(param: string | { key?: string | null; value?: string | null }): void;
+  toString(): string;
+  valueOf(): string;
+}
+interface PmQueryParamList extends PmPropertyList<PmQueryParam> {
+  /** Value of the (first, enabled) param with that key. */
+  get(key: string): string | null | undefined;
+  [name: string]: any;
+}
+interface PmFormParam extends PmProperty {
+  key: string;
+  value?: string;
+  type?: "text" | "file";
+  src?: string | string[];
+  contentType?: string;
+  toString(): string;
+  valueOf(): string;
+}
+interface PmVariable extends PmProperty {
+  key?: string;
+  value?: any;
+  type?: "string" | "boolean" | "number" | "json" | "any";
+  readonly valueType: string;
+  get(): any;
+  set(value: any): void;
+  cast(value: any, type: string): any;
+  castIn(value: any): any;
+  castOut(value: any): any;
+  update(options: object): void;
+  toString(): string;
+  valueOf(): any;
+}
+interface PmVariableList extends PmPropertyList<PmVariable> {
+  oneNormalizedVariable(key: string): PmVariable | undefined;
+  replace(str: string, overrides?: object): string;
+  substitute(obj: any, overrides?: object): any;
+  syncFromObject(obj: Record<string, any>, track?: boolean, prune?: boolean): any;
+  syncToObject(obj?: Record<string, any>): Record<string, any>;
+}
+
+interface PmCookie extends PmPropertyBase {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: string | number | Date;
+  maxAge?: number | string;
+  httpOnly?: boolean;
+  secure?: boolean;
+  hostOnly?: boolean;
+  session?: boolean;
+  sameSite?: string;
+  extensions?: Array<{ key: string; value: string }>;
+  update(cookie: string | object): void;
+  toString(): string;
+  valueOf(): string;
+}
+/** The cookies of the request's domain (Set-Cookie of the response, or the host's jar). */
+interface PmCookieList extends PmPropertyList<PmCookie> {
+  /** Cookie jar: cookies of ANY domain. Every method takes a callback (error, result) OR returns a Promise. */
+  jar(): PmCookieJar;
+  /** Value of the cookie with that name. */
+  get(name: string): string | undefined;
+}
+interface PmCookieJar {
+  set(url: string | PmUrl, name: string, value: string): Promise<void>;
+  set(url: string | PmUrl, name: string, value: string, callback: (error: Error | null) => void): void;
+  set(url: string | PmUrl, cookie: { name: string; value: string; domain?: string; path?: string; expires?: string | number | Date; maxAge?: number; httpOnly?: boolean; secure?: boolean; sameSite?: string }): Promise<void>;
+  set(url: string | PmUrl, cookie: { name: string; value: string; domain?: string; path?: string; expires?: string | number | Date; maxAge?: number; httpOnly?: boolean; secure?: boolean; sameSite?: string }, callback: (error: Error | null) => void): void;
+  get(url: string | PmUrl, name: string): Promise<string | null>;
+  get(url: string | PmUrl, name: string, callback: (error: Error | null, value: string | null) => void): void;
+  getAll(url: string | PmUrl, options?: { http?: boolean; secure?: boolean }): Promise<PmCookie[]>;
+  getAll(url: string | PmUrl, callback: (error: Error | null, cookies: PmCookie[]) => void): void;
+  getAll(url: string | PmUrl, options: { http?: boolean; secure?: boolean }, callback: (error: Error | null, cookies: PmCookie[]) => void): void;
+  unset(url: string | PmUrl, name: string): Promise<void>;
+  unset(url: string | PmUrl, name: string, callback: (error: Error | null) => void): void;
+  clear(url: string | PmUrl): Promise<void>;
+  clear(url: string | PmUrl, callback: (error: Error | null) => void): void;
+}
+
+interface PmUrlDefinition {
+  raw?: string;
+  protocol?: string;
+  host?: string | string[];
+  port?: string | number;
+  path?: string | string[];
+  hash?: string;
+  query?: string | Array<{ key: string; value?: string; disabled?: boolean }>;
+  variable?: Array<{ key: string; value?: any }>;
+  auth?: { user?: string; password?: string };
+}
+/**
+ * pm.request.url — a postman-collection Url that ALSO behaves like the string it
+ * used to be: url.includes("/v1"), url + "?x=1", \`\${url}\`, url.length all work.
+ */
+interface PmUrl extends PmPropertyBase {
+  protocol?: string;
+  auth?: { user?: string; password?: string };
+  host?: string[];
+  port?: string;
+  path?: string[];
+  hash?: string;
+  query: PmQueryParamList;
+  variables: PmVariableList;
+  getHost(): string;
+  getPath(unresolved?: boolean): string;
+  getPathWithQuery(): string;
+  getQueryString(options?: { ignoreDisabled?: boolean; encode?: boolean }): string;
+  getRaw(): string;
+  getRemote(forcePort?: boolean): string;
+  getOAuth1BaseUrl(): string;
+  addQueryParams(params: string | Array<{ key: string; value?: string; disabled?: boolean }>): void;
+  removeQueryParams(params: string | string[] | PmQueryParam[]): void;
+  update(url: string | PmUrlDefinition): void;
+  toString(forceProtocol?: boolean): string;
+  // ── string behaviour (kept for scripts written when the url was a string)
+  readonly length: number;
+  at(index: number): string | undefined;
+  charAt(pos: number): string;
+  charCodeAt(index: number): number;
+  codePointAt(pos: number): number | undefined;
+  concat(...strings: string[]): string;
+  endsWith(searchString: string, endPosition?: number): boolean;
+  includes(searchString: string, position?: number): boolean;
+  indexOf(searchString: string, position?: number): number;
+  lastIndexOf(searchString: string, position?: number): number;
+  localeCompare(that: string): number;
+  match(regexp: string | RegExp): RegExpMatchArray | null;
+  matchAll(regexp: RegExp): IterableIterator<RegExpMatchArray>;
+  normalize(form?: string): string;
+  padEnd(maxLength: number, fillString?: string): string;
+  padStart(maxLength: number, fillString?: string): string;
+  repeat(count: number): string;
+  replace(searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)): string;
+  replaceAll(searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)): string;
+  search(regexp: string | RegExp): number;
+  slice(start?: number, end?: number): string;
+  split(separator: string | RegExp, limit?: number): string[];
+  startsWith(searchString: string, position?: number): boolean;
+  substr(from: number, length?: number): string;
+  substring(start: number, end?: number): string;
+  toLocaleLowerCase(): string;
+  toLocaleUpperCase(): string;
+  toLowerCase(): string;
+  toUpperCase(): string;
+  trim(): string;
+  trimEnd(): string;
+  trimStart(): string;
+  valueOf(): string;
+  [Symbol.toPrimitive](hint?: string): string;
+}
+
+interface PmRequestBody extends PmPropertyBase {
+  mode?: "raw" | "urlencoded" | "formdata" | "file" | "graphql";
+  raw?: string;
+  urlencoded?: PmPropertyList<PmQueryParam>;
+  formdata?: PmPropertyList<PmFormParam>;
+  file?: { src?: string; content?: string };
+  graphql?: { query?: string; variables?: string | object };
+  options?: { raw?: { language?: string } };
+  disabled?: boolean;
+  isEmpty(): boolean;
+  /** Body as text (raw / urlencoded / graphql). */
+  toString(): string;
+  update(options: string | { mode?: string; raw?: string; urlencoded?: any; formdata?: any; graphql?: any; file?: any; options?: any }): void;
+}
+interface PmRequestAuth extends PmProperty {
+  type: string;
+  current(): any;
+  clear(type: string): void;
+  parameters(): PmVariableList;
+  use(type: string, options?: object): void;
+  update(options: object | PmVariable[], type?: string): void;
+}
+
+interface PmRequestDefinition {
+  url: string | PmUrl | PmUrlDefinition;
+  method?: string;
+  header?: Record<string, string> | Array<{ key: string; value: string; disabled?: boolean }> | string | PmHeaderList;
+  headers?: Record<string, string> | Array<{ key: string; value: string; disabled?: boolean }> | string | PmHeaderList;
+  /** Postman's body object; unknown modes / extra parts are accepted (pasted collections vary). */
+  body?: string | PmRequestBodyDefinition | { mode: string; [part: string]: any } | null;
+  /** Milliseconds. */
+  timeout?: number;
+  description?: string;
+}
+type PmRequestBodyDefinition =
+  | { mode: "raw"; raw: string; options?: { raw?: { language?: string } } }
+  | { mode: "urlencoded"; urlencoded: Array<{ key: string; value?: string; disabled?: boolean }> }
+  | { mode: "formdata"; formdata: Array<{ key: string; value?: string; type?: "text" | "file"; disabled?: boolean }> }
+  | { mode: "graphql"; graphql: { query: string; variables?: string | object } }
+  | { mode: "file"; file: { src?: string } };
+
+interface PmSizeInfo {
+  body: number;
+  header: number;
+  total: number;
+  source?: string;
+}
+`;
+const REQUEST_TYPES = `
+/** pm.request — a postman-collection Request plus Callman's helpers. In post-response / tests it is read-only in effect (the call has been made). */
+interface PmRequest extends PmProperty {
+  /** A Url that also behaves like a string. Assign a string to replace it: pm.request.url = "https://…". */
+  get url(): PmUrl;
+  set url(value: string | PmUrl);
+  method: string;
+  readonly headers: PmHeaderList;
+  body: PmRequestBody;
+  /** Only set when the request carries Postman-style auth (Callman does not populate it). */
+  auth?: PmRequestAuth;
+  addHeader(header: string | { key: string; value: string; disabled?: boolean }): void;
+  removeHeader(toRemove: string | PmHeader, ignoreCase?: boolean): void;
+  upsertHeader(header: { key: string; value: string }): void;
+  forEachHeader(callback: (header: PmHeader, context?: any) => void): void;
+  getHeaders(options?: { ignoreCase?: boolean; enabled?: boolean }): Record<string, string>;
+  addQueryParams(params: string | Array<{ key: string; value?: string; disabled?: boolean }>): void;
+  removeQueryParams(params: string | string[] | PmQueryParam[]): void;
+  authorizeUsing(type: string | object, options?: object): void;
+  update(options: string | PmRequestDefinition): void;
+  size(): PmSizeInfo;
+  clone(): PmRequest;
+  /** chai-postman assertions, e.g. pm.request.to.have.header("Authorization"). */
+  readonly to: PmAssertion;
+  // ── Callman helpers
+  /** Query params of the url (same list as pm.request.url.query). */
+  readonly query: PmQueryParamList;
+  getHeader(name: string): string | undefined;
+  setHeader(name: string, value: any): void;
+  unsetHeader(name: string): void;
+  getQueryParam(name: string): string | undefined;
+  setQueryParam(name: string, value: any): void;
+  unsetQueryParam(name: string): void;
+  setMethod(method: string): void;
+  setUrl(url: string): void;
+  /** Replace the body with raw text (non-strings are stringified). */
+  setRawBody(value: any): void;
+}
+`;
+const RESPONSE_TYPES = `
+interface PmResponseDetails {
+  name?: string;
+  code: number;
+  detail?: string;
+  standardName?: string;
+}
+interface PmResponseContentInfo {
+  mimeType: string;
+  mimeFormat: string;
+  charset: string;
+  fileExtension: string;
+  fileName?: string;
+  contentType: string;
+}
+/** pm.response — a postman-collection Response plus Callman's accessors. Not available in pre-request scripts. */
+interface PmResponse extends PmProperty {
+  /** HTTP status code (number). */
+  readonly code: number;
+  /** Status REASON PHRASE ("OK", "Not Found") — Postman semantics. The number is pm.response.code. */
+  readonly status: string;
+  /** Reason phrase (method form of .status). */
+  reason(): string;
+  readonly headers: PmHeaderList;
+  readonly cookies: PmCookieList;
+  /** Round-trip time in ms. */
+  readonly responseTime: number;
+  /** Body size in bytes. */
+  readonly responseSize: number;
+  /** Body bytes. */
+  readonly stream: Buffer;
+  /** Body as text. */
+  text(): string;
+  /** Parse the body as JSON. THROWS when the body is empty or not valid JSON. */
+  json(reviver?: (key: string, value: any) => any): CallmanResponseBody;
+  /** Parse a JSONP body (callback name optional). Throws when it is not valid. */
+  jsonp(callbackName?: string, reviver?: (key: string, value: any) => any): any;
+  size(): PmSizeInfo;
+  /** The body as a data: URI. */
+  dataURI(): string;
+  details(): PmResponseDetails;
+  contentInfo(): PmResponseContentInfo;
+  encoding(): { format: string; source: string };
+  mime(): PmResponseContentInfo;
+  update(options: object): void;
+  // ── Callman accessors
+  /** true for 2xx / 3xx. */
+  readonly ok: boolean;
+  /** Same as .reason(). */
+  readonly statusText: string;
+  /** Parsed body: JSON value for JSON responses, otherwise the text. Prefer .json() / .text(). */
+  readonly body: any;
+  readonly data: any;
+  /** Raw body text (same as .text()). */
+  readonly rawBody: string;
+  readonly raw: string;
+  /** Content-Type header value. */
+  readonly contentType: string;
+  /** Same as .responseTime. */
+  readonly durationMs: number;
+  /** Same as .responseSize. */
+  readonly sizeBytes: number;
+  /** chai-postman assertions: pm.response.to.have.status(200), .to.be.ok, .to.have.jsonBody("a.b", 1), … (to, be and have are the same entry point). */
+  readonly to: PmAssertion;
+  readonly be: PmAssertion;
+  readonly have: PmAssertion;
+}
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// pm.expect (chai 4.4.1 + chai-postman + Callman's jest-style aliases)
+// ───────────────────────────────────────────────────────────────────────────
+const ASSERTION_TYPES = `
+/** A chai 4 assertion plus chai-postman helpers (HTTP predicates) and Callman's jest-style aliases. */
+interface PmAssertion {
+  // ── language chains (no behaviour)
+  readonly to: PmAssertion;
+  readonly be: PmAssertion;
+  readonly been: PmAssertion;
+  readonly is: PmAssertion;
+  readonly that: PmAssertion;
+  readonly which: PmAssertion;
+  readonly and: PmAssertion;
+  readonly has: PmAssertion;
+  readonly have: PmAssertion;
+  readonly with: PmAssertion;
+  readonly at: PmAssertion;
+  readonly of: PmAssertion;
+  readonly same: PmAssertion;
+  readonly but: PmAssertion;
+  readonly does: PmAssertion;
+  readonly still: PmAssertion;
+  readonly also: PmAssertion;
+  // ── flags
+  /** Negate the assertion that follows. */
+  readonly not: PmAssertion;
+  /** Use deep (structural) equality for the assertion that follows. */
+  readonly deep: PmAssertion;
+  /** Use dot / bracket path notation with .property / .include. */
+  readonly nested: PmAssertion;
+  /** Only own (non-inherited) properties. */
+  readonly own: PmAssertion;
+  /** Compare .members in order. */
+  readonly ordered: PmAssertion;
+  readonly any: PmAssertion;
+  readonly all: PmAssertion;
+  /** Make .respondTo look at the constructor's own methods. */
+  readonly itself: PmAssertion;
+  // ── property assertions (no parentheses)
+  readonly ok: PmAssertion;
+  readonly true: PmAssertion;
+  readonly false: PmAssertion;
+  readonly null: PmAssertion;
+  readonly undefined: PmAssertion;
+  readonly NaN: PmAssertion;
+  readonly exist: PmAssertion;
+  readonly exists: PmAssertion;
+  readonly empty: PmAssertion;
+  readonly arguments: PmAssertion;
+  readonly Arguments: PmAssertion;
+  readonly extensible: PmAssertion;
+  readonly sealed: PmAssertion;
+  readonly frozen: PmAssertion;
+  readonly finite: PmAssertion;
+  // ── type / inclusion / length (callable AND chainable)
+  /** .a("string") / .an("array") / .a("object") … */
+  a: PmChainableAssertion<(type: string, message?: string) => PmAssertion>;
+  an: PmChainableAssertion<(type: string, message?: string) => PmAssertion>;
+  include: PmChainableAssertion<(value: any, message?: string) => PmAssertion>;
+  includes: PmChainableAssertion<(value: any, message?: string) => PmAssertion>;
+  contain: PmChainableAssertion<(value: any, message?: string) => PmAssertion>;
+  contains: PmChainableAssertion<(value: any, message?: string) => PmAssertion>;
+  length: PmChainableAssertion<(length: number, message?: string) => PmAssertion>;
+  lengthOf: PmChainableAssertion<(length: number, message?: string) => PmAssertion>;
+  // ── comparison
+  equal(value: any, message?: string): PmAssertion;
+  equals(value: any, message?: string): PmAssertion;
+  eq(value: any, message?: string): PmAssertion;
+  eql(value: any, message?: string): PmAssertion;
+  eqls(value: any, message?: string): PmAssertion;
+  above(value: number | Date, message?: string): PmAssertion;
+  gt(value: number | Date, message?: string): PmAssertion;
+  greaterThan(value: number | Date, message?: string): PmAssertion;
+  least(value: number | Date, message?: string): PmAssertion;
+  gte(value: number | Date, message?: string): PmAssertion;
+  greaterThanOrEqual(value: number | Date, message?: string): PmAssertion;
+  below(value: number | Date, message?: string): PmAssertion;
+  lt(value: number | Date, message?: string): PmAssertion;
+  lessThan(value: number | Date, message?: string): PmAssertion;
+  most(value: number | Date, message?: string): PmAssertion;
+  lte(value: number | Date, message?: string): PmAssertion;
+  lessThanOrEqual(value: number | Date, message?: string): PmAssertion;
+  within(start: number | Date, finish: number | Date, message?: string): PmAssertion;
+  closeTo(expected: number, delta: number, message?: string): PmAssertion;
+  approximately(expected: number, delta: number, message?: string): PmAssertion;
+  instanceof(constructor: Function, message?: string): PmAssertion;
+  instanceOf(constructor: Function, message?: string): PmAssertion;
+  oneOf(list: any[], message?: string): PmAssertion;
+  members(set: any[], message?: string): PmAssertion;
+  satisfy(matcher: (value: any) => boolean, message?: string): PmAssertion;
+  satisfies(matcher: (value: any) => boolean, message?: string): PmAssertion;
+  match(pattern: RegExp, message?: string): PmAssertion;
+  matches(pattern: RegExp, message?: string): PmAssertion;
+  /** String contains the substring. */
+  string(substring: string, message?: string): PmAssertion;
+  // ── object shape
+  /** With dot / bracket paths by default ("a.b[0]"); with a second argument the value must match. */
+  property(name: string | symbol, value?: any, message?: string): PmAssertion;
+  ownProperty(name: string | symbol, value?: any, message?: string): PmAssertion;
+  haveOwnProperty(name: string | symbol, value?: any, message?: string): PmAssertion;
+  ownPropertyDescriptor(name: string | symbol, descriptor?: PropertyDescriptor, message?: string): PmAssertion;
+  haveOwnPropertyDescriptor(name: string | symbol, descriptor?: PropertyDescriptor, message?: string): PmAssertion;
+  key(...keys: string[]): PmAssertion;
+  keys(...keys: Array<string | string[]>): PmAssertion;
+  keys(keys: object): PmAssertion;
+  respondTo(method: string, message?: string): PmAssertion;
+  respondsTo(method: string, message?: string): PmAssertion;
+  throw(errorLike?: Function | Error | RegExp | string, errMsgMatcher?: RegExp | string, message?: string): PmAssertion;
+  throws(errorLike?: Function | Error | RegExp | string, errMsgMatcher?: RegExp | string, message?: string): PmAssertion;
+  Throw(errorLike?: Function | Error | RegExp | string, errMsgMatcher?: RegExp | string, message?: string): PmAssertion;
+  // ── change tracking
+  change(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  changes(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  increase(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  increases(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  decrease(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  decreases(subject: object | (() => any), property?: string, message?: string): PmAssertion;
+  by(delta: number, message?: string): PmAssertion;
+  /** chai's low-level hook for custom assertions. */
+  assert(expression: any, message: string, negateMessage: string, expected?: any, actual?: any, showDiff?: boolean): void;
+  // ── Callman / jest-style aliases
+  toBe(expected: any): PmAssertion;
+  toEqual(expected: any): PmAssertion;
+  toContain(expected: any): PmAssertion;
+  toBeDefined(): PmAssertion;
+  toBeTruthy(): PmAssertion;
+  toBeFalsy(): PmAssertion;
+  toBeGreaterThan(expected: number): PmAssertion;
+  toBeLessThan(expected: number): PmAssertion;
+  // ── chai-postman: HTTP assertions on pm.response / pm.request (the status / header / body forms also work on plain objects)
+  /** pm.response.to.have.status(200) or .status("OK"). */
+  status(codeOrReason: number | string): PmAssertion;
+  statusCode(code: number): PmAssertion;
+  statusCodeClass(classCode: number): PmAssertion;
+  statusReason(reason: string): PmAssertion;
+  /** Header exists / has that value (case-insensitive name). */
+  header(name: string, value?: string): PmAssertion;
+  /** Body is non-empty, equals / contains a string, or matches a RegExp / object. */
+  body(expected?: string | RegExp | object): PmAssertion;
+  /** Body is JSON; optionally a dot-path, and the value at it. */
+  jsonBody(path?: string | object, value?: any): PmAssertion;
+  /** Body validates against a JSON schema (ajv). Works on any value: pm.expect(obj).to.have.jsonSchema(schema). */
+  jsonSchema(schema: object, ajvOptions?: object): PmAssertion;
+  /** Chain into .below() / .above() / .within() — pm.response.to.have.responseTime.below(200). */
+  readonly responseTime: PmAssertion;
+  readonly responseSize: PmAssertion;
+  /** 2xx. */
+  readonly success: PmAssertion;
+  /** 1xx. */
+  readonly info: PmAssertion;
+  /** 3xx. */
+  readonly redirection: PmAssertion;
+  /** 4xx. */
+  readonly clientError: PmAssertion;
+  /** 5xx. */
+  readonly serverError: PmAssertion;
+  /** 4xx or 5xx. */
+  readonly error: PmAssertion;
+  readonly accepted: PmAssertion;
+  readonly badRequest: PmAssertion;
+  readonly unauthorized: PmAssertion;
+  readonly unauthorised: PmAssertion;
+  readonly forbidden: PmAssertion;
+  readonly notFound: PmAssertion;
+  readonly notAcceptable: PmAssertion;
+  readonly rateLimited: PmAssertion;
+  readonly withoutContent: PmAssertion;
+  readonly withBody: PmAssertion;
+  readonly json: PmAssertion;
+  readonly xml: PmAssertion;
+  readonly html: PmAssertion;
+  /** The subject is a postman-collection Request / Response. */
+  readonly postmanRequest: PmAssertion;
+  readonly postmanResponse: PmAssertion;
+  readonly postmanRequestOrResponse: PmAssertion;
+}
+/** A chai chainable method: callable, and still an assertion for chains like .to.have.length.above(2). */
+type PmChainableAssertion<Call extends (...args: any[]) => any> = PmAssertion & Call;
+
+interface PmExpect {
+  /** Start a chai assertion. Fails the surrounding pm.test (or the script when used outside one). */
+  <T = any>(actual: T, message?: string): PmAssertion;
+  /** Throw an AssertionError. */
+  fail(message?: string): never;
+  fail(actual: any, expected: any, message?: string, operator?: string): never;
+}
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// Variables, info, execution
+// ───────────────────────────────────────────────────────────────────────────
+const VARIABLE_TYPES = `
+type PmVariableType = "string" | "boolean" | "number" | "json" | "any";
+
+/** pm.environment / pm.globals / pm.collectionVariables. */
+interface PmVariableScope {
+  /** Scope name (the active environment's name for pm.environment). */
+  readonly name: string;
+  /** Raw string values as they will be stored. */
+  readonly values: Record<string, string>;
+  /** The value as it was set (numbers, objects… stay native within the run; stored values are strings / JSON). */
+  get(key: string): any;
+  set(key: string, value: any, type?: PmVariableType): void;
+  unset(key: string): void;
+  has(key: string): boolean;
+  clear(): void;
+  toObject(): Record<string, any>;
+  /** Resolve {{variables}} against THIS scope. Unresolved {{x}} stay as written; objects and arrays are walked. */
+  replaceIn(template: string): string;
+  replaceIn<T extends object>(template: T): T;
+  replaceIn(template: any): any;
+}
+
+/** pm.variables — read through every scope (local > iteration data > environment > collection > globals). */
+interface PmVariables {
+  get(key: string): any;
+  /** Writes the run-local scope (shared by the scripts of one request). */
+  set(key: string, value: any, type?: PmVariableType): void;
+  unset(key: string): void;
+  has(key: string): boolean;
+  clear(): void;
+  toObject(): Record<string, any>;
+  /** Postman's replaceIn: unresolved {{x}} stay as written; objects and arrays are walked. */
+  replaceIn(template: string): string;
+  replaceIn<T extends object>(template: T): T;
+  replaceIn(template: any): any;
+  /** Callman's older resolver: like replaceIn on a string, but unresolved {{x}} become "". */
+  resolve(template: any): string;
+}
+
+/** pm.iterationData — the data-file row of the current iteration. */
+interface PmIterationData {
+  get(key: string): any;
+  set(key: string, value: any): void;
+  unset(key: string): void;
+  has(key: string): boolean;
+  clear(): void;
+  toObject(): Record<string, any>;
+  toJSON(): Record<string, any>;
+  replaceIn(template: string): string;
+  replaceIn<T extends object>(template: T): T;
+  replaceIn(template: any): any;
+}
+
+interface PmInfo {
+  /** "prerequest" in pre-request scripts, "test" in post-response / tests scripts, "scenario-script" in scenario script nodes. */
+  readonly eventName: "prerequest" | "test" | "scenario-script" | (string & {});
+  /** 0-based iteration index (0 outside a data-driven run). */
+  readonly iteration: number;
+  /** Total iterations (1 outside a data-driven run). */
+  readonly iterationCount: number;
+  readonly requestName: string;
+  readonly requestId: string;
+}
+
+interface PmExecutionLocation extends Array<string> {
+  /** Name of the current request (last segment). */
+  readonly current: string;
+}
+interface PmExecution {
+  /** Run the request with this name / id next (collection runs). null stops the run after the current request. */
+  setNextRequest(request: string | null | undefined): void;
+  /** Folder path to the current request. */
+  readonly location: PmExecutionLocation;
+  /** Not supported in Callman yet — always throws. */
+  runRequest(request: string, options?: { variables?: Record<string, any> }): Promise<never>;
+  /** Skip the current request (its post-response / tests scripts do not run). Only takes effect in a PRE-REQUEST script; elsewhere it has no effect. */
+  skipRequest(): void;
+}
+interface PmExecutionPreRequest extends PmExecution {}
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// Callman-specific APIs
+// ───────────────────────────────────────────────────────────────────────────
+const CALLMAN_TYPES = `
+interface PmDbPhaseResult {
+  success: boolean;
+  error: string | null;
+  rowCount: number;
+  rows: any[];
+  /** First row or null. Oracle column names are UPPERCASE. */
+  firstRow(): any;
+}
+/** The post-response DB query result is only populated in the tests script; here it is always empty. */
+interface PmDbEmptyResult {
+  success: boolean;
+  error: string | null;
+  rowCount: number;
+  rows: never[];
+  firstRow(): null;
+}
+interface PmDbQueryResult extends PmDbPhaseResult {
+  connectionId: string;
+  connectionName: string;
+  connectionType: string;
+  phase: "pre" | "post" | "manual";
+  query: string;
+  resolvedQuery: string;
+  durationMs: number;
+  executedAt: string;
+}
+interface PmDbQueryInput {
+  /** Defaults to the request's configured connection. */
+  connectionId?: string;
+  /** SQL text; for MongoDB a JSON string of a command object. */
+  query: string;
+}
+
+interface PmRedisCommandResult {
+  success: boolean;
+  error: string | null;
+  connectionId: string;
+  connectionName: string;
+  command: string;
+  resolvedCommand: string;
+  commandName: string;
+  key: string | null;
+  result: any;
+  resultText: string;
+  phase: "pre" | "post" | "manual";
+  durationMs: number;
+  executedAt: string;
+}
+interface PmRedisApi {
+  /** Value already captured by a declared GET command (synchronous). */
+  get(key: string): any;
+  /** Results of the declared pre / post commands, by line index. */
+  readonly results: { pre: any[]; post: any[] };
+  /** Run an ad-hoc command — always await it. */
+  command(input: { connectionId?: string; command: string }): Promise<PmRedisCommandResult>;
+}
+
+/** pm.random.* — every generator returns a STRING (int / boolean / bigdecimal too). */
+interface PmRandom {
+  uuid(): string;
+  int(min?: number, max?: number): string;
+  string(length?: number): string;
+  email(): string;
+  phone(): string;
+  name(): string;
+  date(format?: string): string;
+  boolean(): "true" | "false";
+  bigdecimal(min?: number, max?: number, scale?: number): string;
+}
+interface PmCounter {
+  /** Next value of the run counter (starts at 1). */
+  next(): number;
+  /** Counter that starts at startAt (default 1). */
+  start(startAt?: number): number;
+}
+
+interface ScenarioNodeExecutionMeta {
+  status: "success" | "failed" | "skipped";
+  success: boolean;
+  failed: boolean;
+  skipped: boolean;
+  attempts: number;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  continueAfterFailure?: boolean;
+  error?: { message?: string | null; code?: string | null; type?: string | null } | null;
+}
+interface WorkflowExecutionMeta {
+  status: "success" | "failed" | "partial";
+  success: boolean;
+  failed: boolean;
+  totalNodes: number;
+  successfulNodes: number;
+  failedNodes: number;
+  skippedNodes: number;
+  totalRetries: number;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  currentNode?: string | null;
+  lastNode?: string | null;
+  failedNode?: string | null;
+}
+
+interface PmSendRequestCallback {
+  (error: Error | null, response: PmResponse, history?: any): void;
+}
+interface PmSendRequest {
+  /**
+   * Send an HTTP request from a script. Accepts a URL string, Postman's request
+   * options, or a postman-collection Request. Resolves to a Response (same API as
+   * pm.response); the optional callback gets (error, response) too.
+   */
+  (request: string | PmRequestDefinition | PmRequest, callback?: PmSendRequestCallback): Promise<PmResponse>;
+}
+
+interface PmVisualizer {
+  /** Render a Handlebars HTML template with data in the Visualize tab. */
+  set(template: string, data?: object, options?: object): void;
+  clear(): void;
+}
+
+interface PmTest {
+  /** Register a test. The callback runs synchronously; a throw marks the test failed. Use (done) => … for callback-style async. */
+  (name: string, fn?: (done: (error?: any) => void) => any): Promise<void>;
+  /** Record a skipped test (the callback is not run). */
+  skip(name: string, reason?: any): void;
+  /** Number of tests recorded so far in this script. */
+  index(): number;
+}
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// Library facades for require() / pm.require()
+// ───────────────────────────────────────────────────────────────────────────
+const MODULE_TYPES = `
+interface PmLodashChain<T = any> {
+  value(): T;
+  map<R>(iteratee: ((value: any, indexOrKey: any) => R) | string): PmLodashChain<R[]>;
+  filter(predicate?: ((value: any, indexOrKey: any) => any) | object | string): PmLodashChain<T>;
+  reject(predicate?: ((value: any, indexOrKey: any) => any) | object | string): PmLodashChain<T>;
+  sortBy(...iteratees: Array<((value: any) => any) | string>): PmLodashChain<T>;
+  groupBy(iteratee?: ((value: any) => any) | string): PmLodashChain<Record<string, any[]>>;
+  keyBy(iteratee?: ((value: any) => any) | string): PmLodashChain<Record<string, any>>;
+  uniq(): PmLodashChain<T>;
+  flatten(): PmLodashChain<any[]>;
+  compact(): PmLodashChain<T>;
+  take(n?: number): PmLodashChain<T>;
+  reverse(): PmLodashChain<T>;
+  first(): PmLodashChain<any>;
+  last(): PmLodashChain<any>;
+  size(): PmLodashChain<number>;
+  sum(): PmLodashChain<number>;
+  toPairs(): PmLodashChain<Array<[string, any]>>;
+  keys(): PmLodashChain<string[]>;
+  values(): PmLodashChain<any[]>;
+  [method: string]: any;
+}
+/** lodash (the global _ and require("lodash")). Unlisted methods are available through the index signature. */
+interface PmLodash {
+  <T = any>(value: T): PmLodashChain<T>;
+  /** Explicit chain: _.chain(x).map(...).value(). */
+  chain<T = any>(value: T): PmLodashChain<T>;
+  VERSION: string;
+  filter<T>(collection: T[] | Record<string, T> | null | undefined, predicate?: ((value: T, indexOrKey: any) => any) | Partial<T> | string | [string, any]): T[];
+  reject<T>(collection: T[] | Record<string, T> | null | undefined, predicate?: ((value: T, indexOrKey: any) => any) | Partial<T> | string | [string, any]): T[];
+  map<T, R>(collection: T[] | Record<string, T> | null | undefined, iteratee: ((value: T, indexOrKey: any) => R) | string): R[];
+  forEach<T>(collection: T[] | Record<string, T> | null | undefined, iteratee: (value: T, indexOrKey: any) => any): any;
+  each<T>(collection: T[] | Record<string, T> | null | undefined, iteratee: (value: T, indexOrKey: any) => any): any;
+  find<T>(collection: T[] | Record<string, T> | null | undefined, predicate?: ((value: T, indexOrKey: any) => any) | Partial<T> | string | [string, any]): T | undefined;
+  findIndex<T>(array: T[] | null | undefined, predicate?: ((value: T) => any) | Partial<T> | string | [string, any]): number;
+  some<T>(collection: T[] | Record<string, T> | null | undefined, predicate?: ((value: T) => any) | Partial<T> | string | [string, any]): boolean;
+  every<T>(collection: T[] | Record<string, T> | null | undefined, predicate?: ((value: T) => any) | Partial<T> | string | [string, any]): boolean;
+  includes<T>(collection: T[] | Record<string, T> | string | null | undefined, value: T, fromIndex?: number): boolean;
+  groupBy<T>(collection: T[] | Record<string, T> | null | undefined, iteratee?: ((value: T) => any) | string | object): Record<string, T[]>;
+  keyBy<T>(collection: T[] | Record<string, T> | null | undefined, iteratee?: ((value: T) => any) | string): Record<string, T>;
+  countBy<T>(collection: T[] | Record<string, T> | null | undefined, iteratee?: ((value: T) => any) | string): Record<string, number>;
+  sortBy<T>(collection: T[] | Record<string, T> | null | undefined, ...iteratees: any[]): T[];
+  orderBy<T>(collection: T[] | Record<string, T> | null | undefined, iteratees?: any, orders?: any): T[];
+  uniq<T>(array: T[] | null | undefined): T[];
+  uniqBy<T>(array: T[] | null | undefined, iteratee: ((value: T) => any) | string): T[];
+  compact<T>(array: Array<T | null | undefined | false | 0 | ""> | null | undefined): T[];
+  flatten<T>(array: any[] | null | undefined): T[];
+  flattenDeep<T>(array: any[] | null | undefined): T[];
+  chunk<T>(array: T[] | null | undefined, size?: number): T[][];
+  difference<T>(array: T[] | null | undefined, ...values: T[][]): T[];
+  intersection<T>(...arrays: T[][]): T[];
+  union<T>(...arrays: T[][]): T[];
+  zip<T>(...arrays: T[][]): Array<Array<T | undefined>>;
+  first<T>(array: T[] | null | undefined): T | undefined;
+  last<T>(array: T[] | null | undefined): T | undefined;
+  take<T>(array: T[] | null | undefined, n?: number): T[];
+  drop<T>(array: T[] | null | undefined, n?: number): T[];
+  range(start: number, end?: number, step?: number): number[];
+  sum(array: number[] | null | undefined): number;
+  sumBy<T>(array: T[] | null | undefined, iteratee: ((value: T) => number) | string): number;
+  mean(array: number[] | null | undefined): number;
+  min<T>(array: T[] | null | undefined): T | undefined;
+  max<T>(array: T[] | null | undefined): T | undefined;
+  minBy<T>(array: T[] | null | undefined, iteratee: ((value: T) => any) | string): T | undefined;
+  maxBy<T>(array: T[] | null | undefined, iteratee: ((value: T) => any) | string): T | undefined;
+  pick<T extends object>(object: T | null | undefined, ...paths: Array<string | string[]>): Partial<T>;
+  omit<T extends object>(object: T | null | undefined, ...paths: Array<string | string[]>): Partial<T>;
+  pickBy<T extends object>(object: T | null | undefined, predicate?: (value: any, key: string) => any): Partial<T>;
+  omitBy<T extends object>(object: T | null | undefined, predicate?: (value: any, key: string) => any): Partial<T>;
+  merge<T extends object>(object: T, ...sources: any[]): T;
+  assign<T extends object>(object: T, ...sources: any[]): T;
+  defaults<T extends object>(object: T, ...sources: any[]): T;
+  cloneDeep<T>(value: T): T;
+  clone<T>(value: T): T;
+  isEqual(a: any, b: any): boolean;
+  get(object: any, path: string | Array<string | number>, defaultValue?: any): any;
+  set<T extends object>(object: T, path: string | Array<string | number>, value: any): T;
+  has(object: any, path: string | Array<string | number>): boolean;
+  unset(object: any, path: string | Array<string | number>): boolean;
+  keys(object: any): string[];
+  values<T>(object: Record<string, T> | ArrayLike<T> | null | undefined): T[];
+  entries<T>(object: Record<string, T> | null | undefined): Array<[string, T]>;
+  toPairs<T>(object: Record<string, T> | null | undefined): Array<[string, T]>;
+  fromPairs<T>(pairs: Array<[string, T]>): Record<string, T>;
+  mapValues<T, R>(object: Record<string, T> | null | undefined, iteratee: ((value: T, key: string) => R) | string): Record<string, R>;
+  mapKeys<T>(object: Record<string, T> | null | undefined, iteratee: (value: T, key: string) => string): Record<string, T>;
+  invert(object: object): Record<string, string>;
+  size(collection: any): number;
+  isEmpty(value: any): boolean;
+  isArray(value: any): value is any[];
+  isObject(value: any): boolean;
+  isPlainObject(value: any): boolean;
+  isString(value: any): value is string;
+  isNumber(value: any): value is number;
+  isBoolean(value: any): value is boolean;
+  isFunction(value: any): value is Function;
+  isNil(value: any): value is null | undefined;
+  isNull(value: any): value is null;
+  isUndefined(value: any): value is undefined;
+  toString(value: any): string;
+  toNumber(value: any): number;
+  toInteger(value: any): number;
+  camelCase(value?: string): string;
+  kebabCase(value?: string): string;
+  snakeCase(value?: string): string;
+  startCase(value?: string): string;
+  capitalize(value?: string): string;
+  upperFirst(value?: string): string;
+  lowerFirst(value?: string): string;
+  trim(value?: string, chars?: string): string;
+  pad(value?: string, length?: number, chars?: string): string;
+  padStart(value?: string, length?: number, chars?: string): string;
+  padEnd(value?: string, length?: number, chars?: string): string;
+  repeat(value?: string, n?: number): string;
+  random(min?: number, max?: number, floating?: boolean): number;
+  shuffle<T>(collection: T[] | null | undefined): T[];
+  sample<T>(collection: T[] | null | undefined): T | undefined;
+  sampleSize<T>(collection: T[] | null | undefined, n?: number): T[];
+  debounce<F extends (...args: any[]) => any>(fn: F, wait?: number, options?: object): F;
+  throttle<F extends (...args: any[]) => any>(fn: F, wait?: number, options?: object): F;
+  memoize<F extends (...args: any[]) => any>(fn: F, resolver?: (...args: any[]) => any): F;
+  once<F extends (...args: any[]) => any>(fn: F): F;
+  times<R>(n: number, iteratee: (index: number) => R): R[];
+  noop(...args: any[]): void;
+  identity<T>(value: T): T;
+  uniqueId(prefix?: string): string;
+  /** Any other lodash function. */
+  [method: string]: any;
+}
+declare const _: PmLodash;
+
+interface PmMoment {
+  format(pattern?: string): string;
+  add(amount: number | string | object, unit?: string): PmMoment;
+  subtract(amount: number | string | object, unit?: string): PmMoment;
+  startOf(unit: string): PmMoment;
+  endOf(unit: string): PmMoment;
+  diff(other: any, unit?: string, precise?: boolean): number;
+  isBefore(other?: any, unit?: string): boolean;
+  isAfter(other?: any, unit?: string): boolean;
+  isSame(other?: any, unit?: string): boolean;
+  isSameOrBefore(other?: any, unit?: string): boolean;
+  isSameOrAfter(other?: any, unit?: string): boolean;
+  isBetween(from: any, to: any, unit?: string, inclusivity?: string): boolean;
+  isValid(): boolean;
+  clone(): PmMoment;
+  utc(keepLocalTime?: boolean): PmMoment;
+  local(): PmMoment;
+  utcOffset(offset?: number | string): any;
+  unix(): number;
+  valueOf(): number;
+  toDate(): Date;
+  toISOString(keepOffset?: boolean): string;
+  toJSON(): string;
+  toArray(): number[];
+  toObject(): object;
+  fromNow(withoutSuffix?: boolean): string;
+  toNow(withoutSuffix?: boolean): string;
+  from(other: any, withoutSuffix?: boolean): string;
+  calendar(reference?: any, formats?: object): string;
+  year(value?: number): any;
+  month(value?: number | string): any;
+  date(value?: number): any;
+  day(value?: number | string): any;
+  hour(value?: number): any;
+  minute(value?: number): any;
+  second(value?: number): any;
+  millisecond(value?: number): any;
+  set(unit: string | object, value?: number): PmMoment;
+  get(unit: string): number;
+  locale(locale?: string): any;
+  [method: string]: any;
+}
+interface PmMomentStatic {
+  (input?: any, format?: string | string[], strict?: boolean): PmMoment;
+  (input: any, format: string, locale: string, strict?: boolean): PmMoment;
+  utc(input?: any, format?: string | string[], strict?: boolean): PmMoment;
+  unix(seconds: number): PmMoment;
+  duration(input?: any, unit?: string): any;
+  isMoment(value: any): value is PmMoment;
+  isDate(value: any): value is Date;
+  isDuration(value: any): boolean;
+  max(...moments: any[]): PmMoment;
+  min(...moments: any[]): PmMoment;
+  locale(locale?: string): string;
+  tz?: any;
+  [member: string]: any;
+}
+
+interface PmChaiStatic {
+  expect: PmExpect;
+  assert: any;
+  should(): any;
+  use(plugin: (chai: any, utils: any) => void): PmChaiStatic;
+  Assertion: any;
+  AssertionError: any;
+  config: Record<string, any>;
+  util: any;
+  version: string;
+  [member: string]: any;
+}
+
+interface PmAjvError {
+  keyword: string;
+  dataPath: string;
+  schemaPath: string;
+  params: Record<string, any>;
+  message?: string;
+}
+interface PmAjvValidate {
+  (data: any): boolean | Promise<any>;
+  errors?: PmAjvError[] | null;
+  schema?: any;
+}
+interface PmAjvInstance {
+  compile(schema: object | boolean): PmAjvValidate;
+  validate(schemaKeyRef: object | string | boolean, data: any): boolean | Promise<any>;
+  addSchema(schema: object | object[], key?: string): PmAjvInstance;
+  addFormat(name: string, format: any): PmAjvInstance;
+  addKeyword(keyword: string, definition: object): PmAjvInstance;
+  getSchema(keyRef: string): PmAjvValidate | undefined;
+  removeSchema(schemaKeyRef?: any): PmAjvInstance;
+  errorsText(errors?: PmAjvError[] | null, options?: { separator?: string; dataVar?: string }): string;
+  errors?: PmAjvError[] | null;
+}
+/** ajv v6 (what Postman ships). */
+interface PmAjvConstructor {
+  new (options?: object): PmAjvInstance;
+  (options?: object): PmAjvInstance;
+}
+
+interface PmCheerioSelection {
+  length: number;
+  [index: number]: any;
+  text(): string;
+  html(): string | null;
+  attr(name: string): string | undefined;
+  attr(name: string, value: string): PmCheerioSelection;
+  find(selector: string): PmCheerioSelection;
+  children(selector?: string): PmCheerioSelection;
+  parent(selector?: string): PmCheerioSelection;
+  first(): PmCheerioSelection;
+  last(): PmCheerioSelection;
+  eq(index: number): PmCheerioSelection;
+  each(callback: (index: number, element: any) => any): PmCheerioSelection;
+  map(callback: (index: number, element: any) => any): PmCheerioSelection;
+  get(): any[];
+  hasClass(name: string): boolean;
+  val(): string | undefined;
+  data(name?: string): any;
+  [member: string]: any;
+}
+interface PmCheerioApi {
+  (selector: any, context?: any): PmCheerioSelection;
+  load(html: string, options?: object): PmCheerioApi;
+  html(selector?: any): string;
+  root(): PmCheerioSelection;
+  [member: string]: any;
+}
+
+interface PmXml2js {
+  parseString(xml: string, callback: (error: Error | null, result: any) => void): void;
+  parseString(xml: string, options: object, callback: (error: Error | null, result: any) => void): void;
+  parseStringPromise(xml: string, options?: object): Promise<any>;
+  Parser: new (options?: object) => { parseString(xml: string, callback: (error: Error | null, result: any) => void): void; parseStringPromise(xml: string): Promise<any> };
+  Builder: new (options?: object) => { buildObject(rootObj: object): string };
+  [member: string]: any;
+}
+
+interface PmTv4 {
+  validate(data: any, schema: object, checkRecursive?: boolean, banUnknownProperties?: boolean): boolean;
+  validateResult(data: any, schema: object, checkRecursive?: boolean, banUnknownProperties?: boolean): { valid: boolean; error: any; missing: string[] };
+  validateMultiple(data: any, schema: object, checkRecursive?: boolean, banUnknownProperties?: boolean): { valid: boolean; errors: any[]; missing: string[] };
+  addSchema(uri: string, schema: object): void;
+  error: any;
+  missing: string[];
+  [member: string]: any;
+}
+
+interface PmUuid {
+  (): string;
+  v4(): string;
+}
+
+interface PmPathModule {
+  sep: string;
+  delimiter: string;
+  join(...paths: string[]): string;
+  resolve(...paths: string[]): string;
+  normalize(path: string): string;
+  relative(from: string, to: string): string;
+  dirname(path: string): string;
+  basename(path: string, suffix?: string): string;
+  extname(path: string): string;
+  isAbsolute(path: string): boolean;
+  parse(path: string): { root: string; dir: string; base: string; ext: string; name: string };
+  format(parts: { root?: string; dir?: string; base?: string; ext?: string; name?: string }): string;
+}
+interface PmAssertModule {
+  (value: any, message?: string): void;
+  ok(value: any, message?: string): void;
+  equal(actual: any, expected: any, message?: string): void;
+  notEqual(actual: any, expected: any, message?: string): void;
+  strictEqual(actual: any, expected: any, message?: string): void;
+  notStrictEqual(actual: any, expected: any, message?: string): void;
+  deepEqual(actual: any, expected: any, message?: string): void;
+  deepStrictEqual(actual: any, expected: any, message?: string): void;
+  notDeepStrictEqual(actual: any, expected: any, message?: string): void;
+  throws(fn: () => any, expected?: any, message?: string): void;
+  doesNotThrow(fn: () => any, message?: string): void;
+  rejects(promiseOrFn: Promise<any> | (() => Promise<any>), expected?: any, message?: string): Promise<void>;
+  match(value: string, regexp: RegExp, message?: string): void;
+  fail(message?: string): never;
+  [member: string]: any;
+}
+interface PmUtilModule {
+  format(format: any, ...args: any[]): string;
+  inspect(value: any, options?: object): string;
+  promisify<F extends (...args: any[]) => any>(fn: F): (...args: any[]) => Promise<any>;
+  inherits(constructor: Function, superConstructor: Function): void;
+  isDeepStrictEqual(a: any, b: any): boolean;
+  types: Record<string, (value: any) => boolean>;
+  TextEncoder: typeof TextEncoder;
+  TextDecoder: typeof TextDecoder;
+  [member: string]: any;
+}
+interface PmEventEmitter {
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  once(event: string | symbol, listener: (...args: any[]) => void): this;
+  off(event: string | symbol, listener: (...args: any[]) => void): this;
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  removeAllListeners(event?: string | symbol): this;
+  emit(event: string | symbol, ...args: any[]): boolean;
+  listeners(event: string | symbol): Function[];
+  listenerCount(event: string | symbol): number;
+  setMaxListeners(n: number): this;
+}
+interface PmEventsModule {
+  new (options?: object): PmEventEmitter;
+  EventEmitter: new (options?: object) => PmEventEmitter;
+  once(emitter: PmEventEmitter, event: string): Promise<any[]>;
+  [member: string]: any;
+}
+interface PmQuerystringModule {
+  parse(str: string, sep?: string, eq?: string, options?: object): Record<string, string | string[]>;
+  stringify(obj: object, sep?: string, eq?: string, options?: object): string;
+  escape(str: string): string;
+  unescape(str: string): string;
+}
+interface PmUrlModule {
+  URL: typeof URL;
+  URLSearchParams: typeof URLSearchParams;
+  parse(url: string, parseQueryString?: boolean): Record<string, any>;
+  format(url: any): string;
+  resolve(from: string, to: string): string;
+  [member: string]: any;
+}
+interface PmBufferModule {
+  Buffer: typeof Buffer;
+  [member: string]: any;
+}
+interface PmStreamModule {
+  Stream: any; Readable: any; Writable: any; Duplex: any; Transform: any; PassThrough: any;
+  pipeline: any; finished: any; promises: any;
+}
+interface PmStringDecoderModule {
+  StringDecoder: new (encoding?: string) => { write(buffer: ArrayBufferView | ArrayBuffer | string): string; end(buffer?: ArrayBufferView | ArrayBuffer | string): string };
+}
+interface PmPunycodeModule {
+  encode(input: string): string;
+  decode(input: string): string;
+  toASCII(input: string): string;
+  toUnicode(input: string): string;
+  ucs2: { decode(input: string): number[]; encode(codePoints: number[]): string };
+  version: string;
+}
+interface PmTimersModule {
+  setTimeout: typeof setTimeout;
+  clearTimeout: typeof clearTimeout;
+  setInterval: typeof setInterval;
+  clearInterval: typeof clearInterval;
+  setImmediate: typeof setImmediate;
+  clearImmediate: typeof clearImmediate;
+}
+/** A class of the postman-collection SDK that is not modelled in detail. */
+interface PmSdkClass {
+  new (definition?: any, ...args: any[]): any;
+  [member: string]: any;
+}
+interface PmPostmanCollectionModule {
+  Request: { new (definition?: string | PmRequestDefinition): PmRequest; isRequest(value: any): value is PmRequest };
+  Response: { new (definition?: object): PmResponse; isResponse(value: any): value is PmResponse; [member: string]: any };
+  Url: { new (definition?: string | PmUrlDefinition): PmUrl; parse(url: string): PmUrlDefinition; isUrl(value: any): boolean };
+  Header: { new (definition?: string | { key: string; value: string }): PmHeader; parse(headers: string): Array<{ key: string; value: string }>; unparse(headers: any): string; isHeader(value: any): boolean; [member: string]: any };
+  HeaderList: { new (parent?: any, headers?: Array<{ key: string; value: string }>): PmHeaderList };
+  QueryParam: { new (definition?: string | { key: string; value?: string }): PmQueryParam; [member: string]: any };
+  Cookie: { new (definition?: string | object): PmCookie; parse(line: string): PmCookie; stringify(cookie: PmCookie | object): string; [member: string]: any };
+  CookieList: { new (parent?: any, cookies?: Array<PmCookie | object>): PmCookieList };
+  Variable: { new (definition?: any): PmVariable; [member: string]: any };
+  VariableList: { new (parent?: any, variables?: Array<PmVariable | object>): PmVariableList };
+  RequestBody: { new (definition?: object): PmRequestBody };
+  RequestAuth: { new (definition?: object): PmRequestAuth };
+  Property: PmSdkClass;
+  PropertyBase: PmSdkClass;
+  PropertyList: PmSdkClass;
+  FormParam: PmSdkClass;
+  Item: PmSdkClass;
+  ItemGroup: PmSdkClass;
+  Collection: PmSdkClass;
+  Event: PmSdkClass;
+  EventList: PmSdkClass;
+  Script: PmSdkClass;
+  Description: PmSdkClass;
+  ProxyConfig: PmSdkClass;
+  ProxyConfigList: PmSdkClass;
+  Certificate: PmSdkClass;
+  CertificateList: PmSdkClass;
+  MutationTracker: PmSdkClass;
+  UrlMatchPattern: PmSdkClass;
+  UrlMatchPatternList: PmSdkClass;
+  VariableScope: PmSdkClass;
+  Version: PmSdkClass;
+}
+`;
+// require() name → type table (declared as an interface so unknown names are a type error).
+const MODULE_TYPE_TABLE = [
+    ["lodash", "PmLodash"],
+    ["moment", "PmMomentStatic"],
+    ["chai", "PmChaiStatic"],
+    ["ajv", "PmAjvConstructor"],
+    ["cheerio", "PmCheerioApi"],
+    ["xml2js", "PmXml2js"],
+    ["tv4", "PmTv4"],
+    ["uuid", "PmUuid"],
+    ["csv-parse/lib/sync", "(input: string | Uint8Array, options?: object) => any[]"],
+    ["postman-collection", "PmPostmanCollectionModule"],
+    ["crypto-js", "CryptoJsApi"],
+    ["atob", "typeof atob"],
+    ["btoa", "typeof btoa"],
+    ["path", "PmPathModule"],
+    ["assert", "PmAssertModule"],
+    ["buffer", "PmBufferModule"],
+    ["util", "PmUtilModule"],
+    ["url", "PmUrlModule"],
+    ["querystring", "PmQuerystringModule"],
+    ["string_decoder", "PmStringDecoderModule"],
+    ["stream", "PmStreamModule"],
+    ["events", "PmEventsModule"],
+    ["punycode", "PmPunycodeModule"],
+    ["timers", "PmTimersModule"],
+];
+const buildModuleMap = () => {
+    const lines = [];
+    const quote = (name) => JSON.stringify(name);
+    for (const [name, type] of MODULE_TYPE_TABLE) {
+        lines.push(`  ${quote(name)}: ${type};`);
+        lines.push(`  ${quote(`node:${name}`)}: ${type};`);
+    }
+    for (const [alias, target] of Object.entries(exports.PM_REQUIRABLE_MODULE_ALIASES)) {
+        const type = MODULE_TYPE_TABLE.find(([name]) => name === target)?.[1] ?? "any";
+        lines.push(`  ${quote(alias)}: ${type};`);
+    }
+    // TypeScript resolves `const _ = require("lodash")` in a JS file as a module
+    // import (error 2307 unless the module exists), so every name also gets an
+    // ambient module declaration pointing at the same type.
+    const ambientModules = [...MODULE_TYPE_TABLE.map(([name]) => name), ...MODULE_TYPE_TABLE.map(([name]) => `node:${name}`), ...Object.keys(exports.PM_REQUIRABLE_MODULE_ALIASES)].map((name) => `declare module ${quote(name)} { const value: PmModuleMap[${quote(name)}]; export = value; }`);
+    return [
+        "/** Modules require() / pm.require() can load. Anything else throws \"Cannot find module\". */",
+        "interface PmModuleMap {",
+        ...lines,
+        "}",
+        "declare function require<K extends keyof PmModuleMap>(name: K): PmModuleMap[K];",
+        "/** Any other name is not available in Callman and throws at run time (\"Cannot find module\"). */",
+        "declare function require(name: string): any;",
+        "declare module \"*\";",
+        ...ambientModules,
+    ].join("\n");
+};
+const CRYPTOJS_TYPES = `
+interface CryptoJsWordArray {
+  words: number[];
+  sigBytes: number;
+  toString(encoder?: CryptoJsEncoder): string;
+  concat(other: CryptoJsWordArray): CryptoJsWordArray;
+  clone(): CryptoJsWordArray;
+}
+interface CryptoJsEncoder {
+  stringify(wordArray: CryptoJsWordArray): string;
+  parse(input: string): CryptoJsWordArray;
+}
+interface CryptoJsCipherParams {
+  ciphertext: CryptoJsWordArray;
+  key?: CryptoJsWordArray;
+  iv?: CryptoJsWordArray;
+  salt?: CryptoJsWordArray;
+  toString(encoder?: CryptoJsEncoder): string;
+}
+interface CryptoJsCipher {
+  encrypt(message: string | CryptoJsWordArray, key: string | CryptoJsWordArray, options?: object): CryptoJsCipherParams;
+  decrypt(ciphertext: string | CryptoJsCipherParams, key: string | CryptoJsWordArray, options?: object): CryptoJsWordArray;
+}
+type CryptoJsHasher = (message: string | CryptoJsWordArray) => CryptoJsWordArray;
+type CryptoJsHmac = (message: string | CryptoJsWordArray, key: string | CryptoJsWordArray) => CryptoJsWordArray;
+/** crypto-js (the global CryptoJS and require("crypto-js")). */
+interface CryptoJsApi {
+  enc: {
+    Utf8: CryptoJsEncoder;
+    Utf16: CryptoJsEncoder;
+    Utf16BE: CryptoJsEncoder;
+    Utf16LE: CryptoJsEncoder;
+    Base64: CryptoJsEncoder;
+    Base64url: CryptoJsEncoder;
+    Hex: CryptoJsEncoder;
+    Latin1: CryptoJsEncoder;
+  };
+  MD5: CryptoJsHasher;
+  SHA1: CryptoJsHasher;
+  SHA224: CryptoJsHasher;
+  SHA256: CryptoJsHasher;
+  SHA384: CryptoJsHasher;
+  SHA512: CryptoJsHasher;
+  SHA3(message: string | CryptoJsWordArray, options?: { outputLength?: number }): CryptoJsWordArray;
+  RIPEMD160: CryptoJsHasher;
+  HmacMD5: CryptoJsHmac;
+  HmacSHA1: CryptoJsHmac;
+  HmacSHA224: CryptoJsHmac;
+  HmacSHA256: CryptoJsHmac;
+  HmacSHA384: CryptoJsHmac;
+  HmacSHA512: CryptoJsHmac;
+  HmacRIPEMD160: CryptoJsHmac;
+  AES: CryptoJsCipher;
+  DES: CryptoJsCipher;
+  TripleDES: CryptoJsCipher;
+  RC4: CryptoJsCipher;
+  RC4Drop: CryptoJsCipher;
+  Rabbit: CryptoJsCipher;
+  RabbitLegacy: CryptoJsCipher;
+  PBKDF2(password: string | CryptoJsWordArray, salt: string | CryptoJsWordArray, options?: { keySize?: number; iterations?: number; hasher?: any }): CryptoJsWordArray;
+  EvpKDF(password: string | CryptoJsWordArray, salt: string | CryptoJsWordArray, options?: { keySize?: number; iterations?: number; hasher?: any }): CryptoJsWordArray;
+  lib: {
+    WordArray: { create(words?: number[] | Uint8Array, sigBytes?: number): CryptoJsWordArray; random(nBytes: number): CryptoJsWordArray };
+    CipherParams: { create(props: object): CryptoJsCipherParams };
+    [member: string]: any;
+  };
+  algo: Record<string, any>;
+  mode: Record<string, any>;
+  pad: Record<string, any>;
+  format: Record<string, any>;
+  kdf: Record<string, any>;
+  x64: Record<string, any>;
+  [member: string]: any;
+}
+declare const CryptoJS: CryptoJsApi;
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// Legacy Postman globals (postman.*, tests[], responseBody, …)
+// ───────────────────────────────────────────────────────────────────────────
+const LEGACY_TYPES = `
+/** Postman's legacy scripting API (disabled when the script starts with "use sandbox2"). Prefer pm.*. */
+interface PostmanLegacy {
+  setEnvironmentVariable(key: string, value: any): void;
+  getEnvironmentVariable(key: string): any;
+  clearEnvironmentVariable(key: string): void;
+  clearEnvironmentVariables(): void;
+  setGlobalVariable(key: string, value: any): void;
+  getGlobalVariable(key: string): any;
+  clearGlobalVariable(key: string): void;
+  clearGlobalVariables(): void;
+  setNextRequest(name: string | null): void;
+  getResponseHeader(name: string): string | undefined;
+  getResponseCookie(name: string): PmCookie | undefined;
+}
+/** Legacy environment / globals: the pm API plus bracket access to variables (environment["token"]). */
+type PmLegacyVariableScope = PmVariableScope & { [variable: string]: any };
+`;
+const LEGACY_REQUEST_GLOBALS = `
+/** Legacy: raw response body text. */
+declare const responseBody: string;
+/** Legacy: { code, name, detail }. */
+declare const responseCode: { code: number; name: string; detail: string };
+/** Legacy: response time in ms. */
+declare const responseTime: number;
+/** Legacy: response headers as a plain object. */
+declare const responseHeaders: Record<string, string>;
+/** Legacy: response cookies as { name: value }. */
+declare const responseCookies: Record<string, string>;
+`;
+// ───────────────────────────────────────────────────────────────────────────
+// Assembly
+// ───────────────────────────────────────────────────────────────────────────
+const dbDeclaration = (stage) => {
+    const members = [];
+    if (stage !== "script") {
+        members.push("  /** Result of the declared pre-request DB query. */", "  readonly pre: PmDbPhaseResult;");
+    }
+    if (stage === "post-response") {
+        members.push("  /** Declared post-response DB query: empty here — it is populated in the tests script. */", "  readonly post: PmDbEmptyResult;");
+    }
+    else if (stage === "tests") {
+        members.push("  /** Result of the declared post-response DB query. */", "  readonly post: PmDbPhaseResult;");
+    }
+    members.push("  /** Run an ad-hoc query — always await it. Rejects when the query fails. */", "  query(input: PmDbQueryInput): Promise<PmDbQueryResult>;");
+    return ["interface PmDbApi {", ...members, "}"].join("\n");
+};
+const pmDeclaration = (stage, scenario) => {
+    const hasRequest = stage !== "script";
+    const hasResponse = stage === "post-response" || stage === "tests";
+    const lines = [
+        "/** The Callman / Postman script API. pm, cm and callman are the same object. */",
+        "interface Pm {",
+        "  /** @deprecated Postman Vault is not supported in Callman yet — using it throws a clear error. */",
+        "  vault: any;",
+        "  /** @deprecated Postman datasets are not supported in Callman yet — using it throws a clear error. */",
+        "  datasets: any;",
+        "  /** @deprecated pm.mock (mock editor) is not supported in Callman yet — using it throws a clear error. */",
+        "  mock: any;",
+        "  /** @deprecated pm.state (mock editor) is not supported in Callman yet — using it throws a clear error. */",
+        "  state: any;",
+        "  /** @deprecated pm.message (streaming protocols) is not supported in Callman yet — using it throws a clear error. */",
+        "  message: any;",
+        "  test: PmTest;",
+        "  expect: PmExpect;",
+        "  /** Active environment variables. */",
+        "  environment: PmVariableScope;",
+        "  /** Alias of pm.environment. */",
+        "  env: PmVariableScope;",
+        "  globals: PmVariableScope;",
+        "  collectionVariables: PmVariableScope;",
+        "  variables: PmVariables;",
+        "  iterationData: PmIterationData;",
+        "  info: PmInfo;",
+        `  execution: ${stage === "pre-request" ? "PmExecutionPreRequest" : "PmExecution"};`,
+        "  /** Cookies of the request's domain; pm.cookies.jar() gives the whole cookie jar. */",
+        "  cookies: PmCookieList;",
+        "  sendRequest: PmSendRequest;",
+        '  /** Load one of the built-in libraries (same as the global require). */',
+        "  require<K extends keyof PmModuleMap>(name: K): PmModuleMap[K];",
+        "  /** Any other name (npm:, jsr:, team packages, fs…) is not available in Callman and throws at run time. */",
+        "  require(name: string): any;",
+        "  /** Structured log entry (like console.log). */",
+        "  log(...args: any[]): void;",
+        "  db: PmDbApi;",
+        "  redis: PmRedisApi;",
+        "  random: PmRandom;",
+        "  counter: PmCounter;",
+    ];
+    if (hasRequest) {
+        lines.push(hasResponse
+            ? "  /** The request that was sent. */"
+            : "  /** The request about to be sent — mutate it here (headers, url, body). */", "  request: PmRequest;");
+    }
+    if (hasResponse) {
+        lines.push("  /** The received response. */", "  response: PmResponse;");
+        lines.push("  visualizer: PmVisualizer;", "  /** Inside a visualizer template: receive the data passed to pm.visualizer.set. */", "  getData(callback: (error: any, data: any) => void): void;");
+    }
+    if (scenario) {
+        lines.push("  /** Output of a scenario node by label (with __meta: status, timing). null when it has not run. */", "  node(label: string): any;");
+    }
+    lines.push("}");
+    return lines.join("\n");
+};
+const globalsDeclaration = (stage, scenario) => {
+    const hasRequest = stage !== "script";
+    const hasResponse = stage === "post-response" || stage === "tests";
+    const legacy = stage !== "script";
+    const lines = [
+        "declare const pm: Pm;",
+        "/** Alias of pm. */",
+        "declare const cm: Pm;",
+        "/** Alias of pm. */",
+        "declare const callman: Pm;",
+        "/** Active environment variables as a plain object. */",
+        "declare const env: Record<string, string>;",
+        "declare const test: PmTest;",
+        "declare const expect: PmExpect;",
+        "declare const db: PmDbApi;",
+        "declare const redis: PmRedisApi;",
+        "declare const random: PmRandom;",
+        "declare const counter: PmCounter;",
+        "declare const variables: PmVariables;",
+        legacy ? "declare const environment: PmLegacyVariableScope;" : "declare const environment: PmVariableScope;",
+    ];
+    if (hasRequest)
+        lines.push("declare const request: PmRequest;");
+    if (hasResponse)
+        lines.push("declare const response: PmResponse;");
+    if (scenario) {
+        lines.push("/** Workflow-level data of the scenario run. */", "declare const workflow: { __meta: WorkflowExecutionMeta; [key: string]: any };");
+    }
+    if (legacy) {
+        lines.push("declare const postman: PostmanLegacy;", "/** Legacy: tests[\"name\"] = boolean records a test. */", "declare const tests: Record<string, any>;", "declare const globals: PmLegacyVariableScope;", "/** Legacy: the current iteration's data row. */", "declare const data: Record<string, any>;", "/** Legacy: 0-based iteration index. */", "declare const iteration: number;", "declare const tv4: PmTv4;", "declare const cheerio: PmCheerioApi;", "/** Legacy: XML string to object. */", "declare function xml2Json(xml: string): any;");
+    }
+    return lines.join("\n");
+};
+/**
+ * The declaration text for one script editor. Add it (and ONE response-body chunk,
+ * see CALLMAN_RESPONSE_BODY_DECLARATION) to a TS language service configured with
+ * lib es2022 and no DOM.
+ */
+const getPmApiDeclarations = (options) => {
+    const { stage } = options;
+    const scenario = options.scenario === true || stage === "script";
+    const hasRequest = stage !== "script";
+    const hasResponse = stage === "post-response" || stage === "tests";
+    const legacy = stage !== "script";
+    const parts = [
+        "// Callman script API — generated from callman-core (pm-api-declarations.ts). Do not edit.",
+        PLATFORM_GLOBALS,
+        SDK_TYPES,
+        ASSERTION_TYPES,
+        VARIABLE_TYPES,
+        CALLMAN_TYPES,
+        dbDeclaration(stage),
+        CRYPTOJS_TYPES,
+        MODULE_TYPES,
+        buildModuleMap(),
+    ];
+    // PmRequest is also what pm.sendRequest accepts and PmResponse is its result, so both are always declared.
+    parts.push(REQUEST_TYPES, RESPONSE_TYPES);
+    if (legacy)
+        parts.push(LEGACY_TYPES);
+    parts.push(pmDeclaration(stage, scenario));
+    parts.push(globalsDeclaration(stage, scenario));
+    if (legacy && hasResponse)
+        parts.push(LEGACY_REQUEST_GLOBALS);
+    return parts.join("\n");
+};
+exports.getPmApiDeclarations = getPmApiDeclarations;
+/** The chunks as virtual files for `addExtraLib(content, path)`. */
+const getPmApiDeclarationLibs = (options) => [
+    { path: exports.PM_API_DECLARATIONS_PATH, content: (0, exports.getPmApiDeclarations)(options) },
+    { path: exports.CALLMAN_RESPONSE_BODY_DECLARATION_PATH, content: exports.CALLMAN_RESPONSE_BODY_DECLARATION },
+];
+exports.getPmApiDeclarationLibs = getPmApiDeclarationLibs;
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/;
+/**
+ * `declare const Label: any;` for every scenario node label that the runtime
+ * exposes as a global (valid identifier, not reserved). Add next to the script
+ * declarations of a scenario script editor.
+ */
+const getScenarioLabelDeclarations = (labels) => {
+    const reserved = new Set(exports.PM_API_RESERVED_NAMES);
+    const seen = new Set();
+    const lines = [];
+    for (const raw of labels) {
+        const label = raw.trim();
+        if (!label || seen.has(label) || !IDENTIFIER_PATTERN.test(label) || reserved.has(label))
+            continue;
+        seen.add(label);
+        lines.push(`declare const ${label}: any;`);
+    }
+    return lines.join("\n");
+};
+exports.getScenarioLabelDeclarations = getScenarioLabelDeclarations;
+// ───────────────────────────────────────────────────────────────────────────
+// What is declared, for the drift check
+// ───────────────────────────────────────────────────────────────────────────
+const PROPERTY_BASE = ["meta", "parent", "setParent", "findInParents", "findParentContaining", "forEachParent", "toJSON"];
+const PROPERTY = [...PROPERTY_BASE, "id", "name", "disabled", "describe", "findSubstitutions", "toObjectResolved"];
+const PROPERTY_LIST = [
+    ...PROPERTY_BASE, "Type", "members", "reference", "add", "append", "prepend", "insert", "insertAfter", "upsert",
+    "assimilate", "populate", "repopulate", "clear", "count", "idx", "indexOf", "one", "get", "has", "all", "each",
+    "eachParent", "map", "filter", "find", "reduce", "remove", "toObject", "toString",
+];
+const VARIABLE_SCOPE = ["name", "values", "get", "set", "unset", "has", "clear", "toObject", "replaceIn"];
+const URL_STRING_METHODS = [
+    "length", "at", "charAt", "charCodeAt", "codePointAt", "concat", "endsWith", "includes", "indexOf", "lastIndexOf",
+    "localeCompare", "match", "matchAll", "normalize", "padEnd", "padStart", "repeat", "replace", "replaceAll", "search",
+    "slice", "split", "startsWith", "substr", "substring", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase",
+    "toUpperCase", "trim", "trimEnd", "trimStart", "valueOf",
+];
+/**
+ * Member names declared per namespace (union over every stage). The drift check
+ * compares this map with (a) the declaration text, via the TypeScript checker,
+ * and (b) the live sandbox objects.
+ */
+exports.PM_API_DECLARED_MEMBERS = {
+    pm: [
+        "test", "expect", "environment", "env", "globals", "collectionVariables", "variables", "iterationData", "info",
+        "execution", "cookies", "sendRequest", "require", "log", "db", "redis", "random", "counter", "request", "response",
+        "visualizer", "getData", "node", "vault", "datasets", "mock", "state", "message",
+    ],
+    "pm.environment": VARIABLE_SCOPE,
+    "pm.globals": VARIABLE_SCOPE,
+    "pm.collectionVariables": VARIABLE_SCOPE,
+    "pm.variables": ["get", "set", "unset", "has", "clear", "toObject", "replaceIn", "resolve"],
+    "pm.iterationData": ["get", "set", "unset", "has", "clear", "toObject", "toJSON", "replaceIn"],
+    "pm.info": ["eventName", "iteration", "iterationCount", "requestName", "requestId"],
+    "pm.execution": ["setNextRequest", "location", "runRequest", "skipRequest"],
+    "pm.cookies": [...PROPERTY_LIST, "jar"],
+    "pm.cookies.jar": ["set", "get", "getAll", "unset", "clear"],
+    "pm.request": [
+        ...PROPERTY, "url", "method", "headers", "body", "auth", "addHeader", "removeHeader", "upsertHeader", "forEachHeader",
+        "getHeaders", "addQueryParams", "removeQueryParams", "authorizeUsing", "update", "size", "clone", "to", "query",
+        "getHeader", "setHeader", "unsetHeader", "getQueryParam", "setQueryParam", "unsetQueryParam", "setMethod", "setUrl",
+        "setRawBody",
+    ],
+    "pm.request.url": [
+        ...PROPERTY_BASE, "protocol", "auth", "host", "port", "path", "hash", "query", "variables", "getHost", "getPath",
+        "getPathWithQuery", "getQueryString", "getRaw", "getRemote", "getOAuth1BaseUrl", "addQueryParams",
+        "removeQueryParams", "update", "toString", ...URL_STRING_METHODS,
+    ],
+    "pm.request.headers": [...PROPERTY_LIST, "contentSize"],
+    "pm.request.url.query": PROPERTY_LIST,
+    "pm.request.body": [
+        ...PROPERTY_BASE, "mode", "raw", "urlencoded", "formdata", "file", "graphql", "options", "disabled", "isEmpty", "toString",
+        "update",
+    ],
+    "pm.response": [
+        ...PROPERTY, "code", "status", "reason", "headers", "cookies", "responseTime", "responseSize", "stream", "text", "json",
+        "jsonp", "size", "dataURI", "details", "contentInfo", "encoding", "mime", "update", "ok", "statusText", "body", "data",
+        "rawBody", "raw", "contentType", "durationMs", "sizeBytes", "to", "be", "have",
+    ],
+    "pm.response.headers": [...PROPERTY_LIST, "contentSize"],
+    "pm.visualizer": ["set", "clear"],
+    "pm.test": ["skip", "index"],
+    "pm.expect": ["fail"],
+    "pm.expect()": [
+        "to", "be", "been", "is", "that", "which", "and", "has", "have", "with", "at", "of", "same", "but", "does", "still", "also",
+        "not", "deep", "nested", "own", "ordered", "any", "all", "itself", "ok", "true", "false", "null", "undefined", "NaN",
+        "exist", "exists", "empty", "arguments", "Arguments", "extensible", "sealed", "frozen", "finite", "a", "an", "include",
+        "includes", "contain", "contains", "length", "lengthOf", "equal", "equals", "eq", "eql", "eqls", "above", "gt",
+        "greaterThan", "least", "gte", "greaterThanOrEqual", "below", "lt", "lessThan", "most", "lte", "lessThanOrEqual",
+        "within", "closeTo", "approximately", "instanceof", "instanceOf", "oneOf", "members", "satisfy", "satisfies", "match",
+        "matches", "string", "property", "ownProperty", "haveOwnProperty", "ownPropertyDescriptor", "haveOwnPropertyDescriptor",
+        "key", "keys", "respondTo", "respondsTo", "throw", "throws", "Throw", "change", "changes", "increase", "increases",
+        "decrease", "decreases", "by", "assert", "toBe", "toEqual", "toContain", "toBeDefined", "toBeTruthy", "toBeFalsy",
+        "toBeGreaterThan", "toBeLessThan", "status", "statusCode", "statusCodeClass", "statusReason", "header", "body", "jsonBody",
+        "jsonSchema", "responseTime", "responseSize", "success", "info", "redirection", "clientError", "serverError", "error",
+        "accepted", "badRequest", "unauthorized", "unauthorised", "forbidden", "notFound", "notAcceptable", "rateLimited",
+        "withoutContent", "withBody", "json", "xml", "html", "postmanRequest", "postmanResponse", "postmanRequestOrResponse",
+    ],
+    "pm.db": ["pre", "post", "query"],
+    "pm.redis": ["get", "results", "command"],
+    "pm.random": ["uuid", "int", "string", "email", "phone", "name", "date", "boolean", "bigdecimal"],
+    "pm.counter": ["next", "start"],
+    console: [
+        "log", "info", "warn", "error", "debug", "trace", "assert", "count", "countReset", "time", "timeLog", "timeEnd", "group",
+        "groupCollapsed", "groupEnd", "table", "dir", "dirxml", "clear",
+    ],
+    // Top-level identifiers declared by this file (union over stages). Language built-ins that
+    // lib es2022 already declares are intentionally absent.
+    globals: [
+        "pm", "cm", "callman", "env", "test", "expect", "db", "redis", "random", "counter", "variables", "environment",
+        "request", "response", "workflow", "postman", "globals", "data", "iteration", "tv4", "cheerio", "xml2Json", "tests",
+        "responseBody", "responseCode", "responseTime", "responseHeaders", "responseCookies", "console", "atob", "btoa",
+        "structuredClone", "queueMicrotask", "setTimeout", "clearTimeout", "setInterval", "clearInterval", "setImmediate",
+        "clearImmediate", "TextEncoder", "TextDecoder", "URL", "URLSearchParams", "Event", "EventTarget", "DOMException",
+        "AbortSignal", "AbortController", "Blob", "File", "ReadableStream", "WritableStream", "TransformStream",
+        "TextEncoderStream", "TextDecoderStream", "Buffer", "crypto", "require", "_", "CryptoJS",
+    ],
+};
+//# sourceMappingURL=pm-api-declarations.js.map