@http-forge/core 0.1.0 → 0.2.1

package/dist/di/platform-adapters.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Platform Adapters
+ *
+ * Interface for platform-specific implementations that must be
+ * provided by the host environment (VS Code, CLI, etc.).
+ *
+ * The core bootstrap uses these adapters to wire up services
+ * without depending on any specific platform.
+ */
+import type { IConsoleService } from '../types/console-service';
+import type { IApplicationInfo, IExternalBrowserService, IFileWatcherFactory, IKeyValueStore, INotificationService, ISecretStore } from '../types/platform';
+/**
+ * Platform adapters required by core service bootstrap.
+ *
+ * The host environment (VS Code extension, CLI tool, etc.) creates
+ * concrete implementations and passes them to `registerCoreServices()`.
+ *
+ * @example VS Code extension:
+ * ```typescript
+ * const adapters: PlatformAdapters = {
+ *   workspaceFolder: '/path/to/workspace',
+ *   fileWatcherFactory: new VscodeFileWatcherFactory(),
+ *   notificationService: new VscodeNotificationService(),
+ *   workspaceStore: new VscodeKeyValueStore(context.workspaceState),
+ *   globalStore: new VscodeKeyValueStore(context.globalState),
+ *   secretStore: vscodeSecretStoreAdapter,
+ *   browserService: vscodeBrowserAdapter,
+ *   applicationInfo: { name: 'HttpForge', version: '1.0.0' },
+ *   consoleService: new ConsoleService('HTTP Forge'),
+ * };
+ * registerCoreServices(container, adapters);
+ * ```
+ */
+export interface PlatformAdapters {
+    /** Workspace root folder path */
+    workspaceFolder: string;
+    /** File watcher factory — watches for file changes (ConfigService, CollectionService) */
+    fileWatcherFactory: IFileWatcherFactory;
+    /** Notification service — shows info/warning/error messages (ConfigService) */
+    notificationService: INotificationService;
+    /** Per-workspace key-value store (EnvironmentConfigService) */
+    workspaceStore: IKeyValueStore;
+    /** Global key-value store (CookieService) */
+    globalStore: IKeyValueStore;
+    /** Secret storage for tokens (OAuth2TokenManager). Optional — OAuth2 disabled if absent. */
+    secretStore?: ISecretStore;
+    /** External browser service for OAuth2 flows. Optional — OAuth2 disabled if absent. */
+    browserService?: IExternalBrowserService;
+    /** Application name/version for User-Agent header (RequestPreparer) */
+    applicationInfo?: IApplicationInfo;
+    /** Structured logging service. Optional — a no-op console is used if absent. */
+    consoleService?: IConsoleService;
+}

package/dist/di/service-container.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Service Container
+ *
+ * Generic dependency injection container.
+ * Platform-agnostic — no VS Code dependencies.
+ *
+ * Principles:
+ * - Dependency Inversion: Services accessed through interfaces
+ * - Single Responsibility: Container only manages service lifecycle
+ * - Open/Closed: New services registered without modifying existing code
+ */
+import type { IAsyncCookieService } from '../cookie/interfaces';
+import type { IRequestPreparer } from '../execution/request-preparer-interfaces';
+import type { IRequestHistoryService } from '../history/request-history-service-interfaces';
+import type { IHttpRequestService } from '../http/interfaces';
+import type { IScriptExecutor } from '../script/interfaces';
+import type { IConsoleService } from '../types/console-service';
+import type { IHttpClient } from '../types/platform';
+import type { ServiceIdentifier } from './service-identifiers';
+import type { IOAuth2TokenManager } from '../auth/interfaces';
+import type { ICollectionService } from '../collection/collection-service-interfaces';
+import type { IConfigService } from '../config';
+import type { IEnvironmentConfigService } from '../environment/interfaces';
+import type { IGraphQLSchemaService } from '../graphql/graphql-schema-service';
+import type { IDataFileParser } from '../platform/data-file-parser';
+import type { ICookieJar } from '../script/interfaces';
+/**
+ * Factory function type for creating services
+ */
+type ServiceFactory<T> = (container: ServiceContainer) => T;
+/**
+ * Service Container implementation
+ * Provides dependency injection capabilities
+ */
+export declare class ServiceContainer {
+    private static _instance;
+    private services;
+    private primitives;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static get instance(): ServiceContainer;
+    /**
+     * Reset the container (useful for testing)
+     */
+    static reset(): void;
+    /**
+     * Register a primitive value (like workspace folder path)
+     */
+    registerValue<T>(identifier: ServiceIdentifier, value: T): this;
+    /**
+     * Register a service factory as a singleton
+     * The service will be created on first resolution and reused
+     */
+    registerSingleton<T>(identifier: ServiceIdentifier, factory: ServiceFactory<T>): this;
+    /**
+     * Register a service factory as transient
+     * A new instance will be created on each resolution
+     */
+    registerTransient<T>(identifier: ServiceIdentifier, factory: ServiceFactory<T>): this;
+    /**
+     * Register an already instantiated service
+     */
+    registerInstance<T>(identifier: ServiceIdentifier, instance: T): this;
+    /**
+     * Resolve a service by its identifier
+     */
+    resolve<T>(identifier: ServiceIdentifier): T;
+    /**
+     * Check if a service is registered
+     */
+    has(identifier: ServiceIdentifier): boolean;
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+    get config(): IConfigService;
+    get console(): IConsoleService;
+    get environmentConfig(): IEnvironmentConfigService;
+    get collection(): ICollectionService;
+    get httpRequest(): IHttpRequestService;
+    get httpClient(): IHttpClient;
+    get cookie(): IAsyncCookieService;
+    get requestHistory(): IRequestHistoryService;
+    get dataFileParser(): IDataFileParser;
+    get scriptExecutor(): IScriptExecutor;
+    get requestPreparer(): IRequestPreparer;
+    get persistentCookieJar(): ICookieJar;
+    get oauth2TokenManager(): IOAuth2TokenManager;
+    get graphqlSchemaService(): IGraphQLSchemaService;
+}
+/**
+ * Convenience function to get the service container instance
+ */
+export declare function getServiceContainer(): ServiceContainer;
+export {};

package/dist/di/service-identifiers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Service Identifiers
+ *
+ * Symbol-based identifiers for type-safe service resolution.
+ * Used by ServiceContainer for dependency injection.
+ */
+export declare const ServiceIdentifiers: {
+    readonly Config: symbol;
+    readonly Console: symbol;
+    readonly EnvironmentConfig: symbol;
+    readonly Collection: symbol;
+    readonly HttpRequest: symbol;
+    readonly HttpClient: symbol;
+    readonly Cookie: symbol;
+    readonly RequestHistory: symbol;
+    readonly UrlBuilder: symbol;
+    readonly RequestPreprocessor: symbol;
+    readonly RequestPreparer: symbol;
+    readonly InterceptorChain: symbol;
+    readonly ScriptExecutor: symbol;
+    readonly DataFileParser: symbol;
+    readonly CollectionRequestExecutor: symbol;
+    readonly WorkspaceFolder: symbol;
+    readonly PersistentCookieJar: symbol;
+    readonly OAuth2TokenManager: symbol;
+    readonly GraphQLSchemaService: symbol;
+    readonly SchemaInferrer: symbol;
+    readonly HistoryAnalyzer: symbol;
+    readonly ScriptAnalyzer: symbol;
+    readonly SchemaInferenceService: symbol;
+    readonly OpenApiExporter: symbol;
+    readonly OpenApiImporter: symbol;
+};
+export type ServiceIdentifier = typeof ServiceIdentifiers[keyof typeof ServiceIdentifiers];

package/dist/environment/environment-config-service.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Environment Configuration Service
+ *
+ * Platform-agnostic — uses IKeyValueStore for persistence instead of
+ * VS Code's workspaceState/globalState.
+ */
+import { IConfigService } from '../config';
+import { IKeyValueStore } from '../types/platform';
+import { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from './interfaces';
+export declare class EnvironmentConfigService implements IEnvironmentConfigService {
+    private workspaceFolder;
+    private workspaceStore;
+    private configService;
+    private environmentsPath;
+    private sharedConfigPath;
+    private localConfigPath;
+    private historiesPath;
+    private sharedConfig;
+    private localConfig;
+    private selectedEnvironment;
+    /**
+     * In-memory Local Values for variables (not persisted)
+     * These are set via forge.*.set() in scripts and override file values
+     * Cleared when the process exits
+     */
+    private localGlobalValues;
+    private localEnvironmentValues;
+    constructor(workspaceFolder: string, workspaceStore: IKeyValueStore, configService: IConfigService);
+    getWorkspaceFolder(): string;
+    getRootPath(): string;
+    loadConfigs(): void;
+    getSharedConfig(): SharedConfig | null;
+    getLocalConfig(): LocalConfig | null;
+    getEnvironmentNames(): string[];
+    getSelectedEnvironment(): string;
+    setSelectedEnvironment(envName: string): Promise<void>;
+    setEnvironmentVariable(key: string, value: unknown): void;
+    deleteEnvironmentVariable(key: string): void;
+    clearEnvironmentVariables(): void;
+    getEnvironmentVariableLocal(key: string): string | undefined;
+    getEnvironmentVariableLocals(): Record<string, string>;
+    setGlobalVariable(key: string, value: unknown): void;
+    getGlobalVariable(key: string): string | undefined;
+    getGlobalVariableLocal(key: string): string | undefined;
+    getGlobalVariables(): Record<string, string>;
+    getGlobalVariableLocals(): Record<string, string>;
+    deleteGlobalVariable(key: string): void;
+    clearGlobalVariables(): void;
+    private getSessionStateKey;
+    setSessionVariable(key: string, value: unknown): Promise<void>;
+    getSessionVariable(key: string): string | undefined;
+    getSessionVariables(): Record<string, string>;
+    deleteSessionVariable(key: string): Promise<void>;
+    clearSessionVariables(): Promise<void>;
+    hasSessionVariable(key: string): boolean;
+    getResolvedEnvironment(envName?: string): ResolvedEnvironment | null;
+    resolveVariables(input: string, envName?: string): string;
+    exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+    resolveVariablesWithExtra(input: string, extraVariables: Record<string, string>, envName?: string): string;
+    resolveVariablesInObject<T>(obj: T, envName?: string): T;
+    resolveVariablesInObjectWithExtra<T>(obj: T, extraVariables: Record<string, string>, envName?: string): T;
+    getHistoriesPath(): string;
+    getSharedConfigPath(): string;
+    getLocalConfigPath(): string;
+    getEnvironmentConfigPath(envName: string): string;
+    localConfigExists(): boolean;
+    saveSharedConfig(config: SharedConfig): void;
+    saveLocalConfig(config: LocalConfig): void;
+    importPostmanEnvironmentFile(filePath: string): ImportedEnvironment;
+    saveEnvLocalConfig(envName: string, variables: Record<string, string>): void;
+    getEnvLocalPath(envName: string): string;
+    private getEnvLocalConfigPath;
+    private loadFolderConfigs;
+    /**
+     * Create a VariableResolver pre-loaded with environment + session variables.
+     */
+    private createResolver;
+    private saveFolderSharedConfig;
+    reload(): void;
+    getAllEnvironments(): Array<{
+        id: string;
+        name: string;
+        active: boolean;
+        variables: Record<string, string>;
+    }>;
+    setActiveEnvironment(environmentId: string): Promise<void>;
+    createEnvironment(name: string): Promise<void>;
+    deleteEnvironment(environmentId: string): Promise<void>;
+    duplicateEnvironment(environmentId: string, newName: string): Promise<void>;
+    renameEnvironment(environmentId: string, newName: string): Promise<void>;
+    private validateEnvironmentName;
+    private validateEnvironmentExists;
+    private validateEnvironmentNameNotTaken;
+    private validateConfigLoaded;
+    updateEnvironmentVariables(environmentId: string, variables: Record<string, string>): Promise<void>;
+    private loadJsonFile;
+    private saveJsonFile;
+}

package/dist/environment/environment-file-loader.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Environment File Loader
+ *
+ * Shared logic for reading the multi-file environment folder format:
+ *   _global.json           — global variables + default headers
+ *   {env}.json             — per-environment variables
+ *   _global.local.json     — local variable overrides (gitignored)
+ *   {env}.local.json       — per-environment local overrides (gitignored)
+ *
+ * Used by both EnvironmentConfigService (extension) and
+ * ForgeContainer.fromForgeRoot (standalone).
+ */
+export interface EnvironmentFolderData {
+    /** Variables available in all environments */
+    globalVariables: Record<string, string>;
+    /** Default headers sent with every request */
+    defaultHeaders: Record<string, string>;
+    /** Per-environment configs keyed by environment name */
+    environments: Record<string, EnvironmentEntry>;
+    /** Local global variable overrides from _global.local.json */
+    localVariables: Record<string, string>;
+    /** Per-environment local variable overrides from {env}.local.json */
+    localCredentials: Record<string, {
+        variables: Record<string, string>;
+    }>;
+}
+export interface EnvironmentEntry {
+    description?: string;
+    requiresConfirmation?: boolean;
+    variables: Record<string, string>;
+}
+/**
+ * Determine whether a filename is a system/meta file (not an environment file).
+ */
+export declare function isSystemEnvironmentFile(fileName: string): boolean;
+/**
+ * Load environment configuration from a multi-file folder.
+ *
+ * @param envDir - Absolute path to the environments folder
+ * @returns Parsed environment data (or empty defaults when the folder is missing)
+ */
+export declare function loadEnvironmentsFromFolder(envDir: string): EnvironmentFolderData;

package/dist/{services → environment}/environment-resolver.d.ts

@@ -4,7 +4,7 @@
  * Single Responsibility: Resolve environment variables for request execution
  * Dependency Inversion: Implements IEnvironmentStore interface
  */
-import { IEnvironmentStore } from '../interfaces';
+import { IEnvironmentStore } from './interfaces';
 /**
  * Environment definition
  */
@@ -15,9 +15,11 @@ export interface Environment {
     inherits?: string;
 }
 /**
- * Environment configuration
+ * Environment store configuration (for EnvironmentResolver)
+ * Note: Named EnvironmentStoreConfig to avoid conflict with
+ * interfaces/environment-config-service.ts EnvironmentConfig
  */
-export interface EnvironmentConfig {
+export interface EnvironmentStoreConfig {
     /** Global variables (available in all environments) */
     globalVariables?: Record<string, string>;
     /** Environment definitions */
@@ -34,7 +36,7 @@ export declare class EnvironmentResolver implements IEnvironmentStore {
     /** In-memory values */
     private sessionGlobals;
     private sessionEnvironmentValues;
-    constructor(config: EnvironmentConfig);
+    constructor(config: EnvironmentStoreConfig);
     /**
      * Get a single variable value
      */
@@ -88,4 +90,3 @@ export declare class EnvironmentResolver implements IEnvironmentStore {
      */
     static fromVariables(variables: Record<string, string>, name?: string): EnvironmentResolver;
 }
-//# sourceMappingURL=environment-resolver.d.ts.map

package/dist/{services → environment}/forge-env.d.ts

@@ -30,8 +30,8 @@
  * env.get('token');  // 'abc'
  * ```
  */
-import { IEnvironmentStore, IVariableInterpolator } from '../interfaces';
 import { EnvironmentResolver } from './environment-resolver';
+import { IEnvironmentStore, IVariableInterpolator } from './interfaces';
 /**
  * ForgeEnv interface - the public API for environment management
  */
@@ -163,4 +163,3 @@ export declare class ForgeEnv implements IForgeEnv {
      */
     static fromResolver(resolver: EnvironmentResolver): ForgeEnv;
 }
-//# sourceMappingURL=forge-env.d.ts.map

package/dist/environment/interfaces.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Environment Configuration Service Interface
+ *
+ * Interface Segregation: Separated into focused sub-interfaces
+ * Dependency Inversion: Consumers depend on this abstraction
+ */
+/**
+ * Environment configuration structure
+ */
+export interface EnvironmentConfig {
+    description?: string;
+    requiresConfirmation?: boolean;
+    variables?: Record<string, string>;
+}
+/**
+ * Shared configuration file structure
+ */
+export interface SharedConfig {
+    environments: Record<string, EnvironmentConfig>;
+    globalVariables?: Record<string, string>;
+    defaultHeaders?: Record<string, string>;
+}
+/**
+ * Local configuration file structure
+ */
+export interface LocalConfig {
+    credentials?: Record<string, {
+        variables?: Record<string, string>;
+    }>;
+    variables?: Record<string, string>;
+}
+/**
+ * Resolved environment with all inherited values
+ */
+export interface ResolvedEnvironment {
+    name: string;
+    description?: string;
+    requiresConfirmation?: boolean;
+    headers: Record<string, string>;
+    variables: Record<string, string>;
+}
+/**
+ * Representation of an imported environment (from Postman)
+ */
+export interface ImportedEnvironment {
+    name: string;
+    variables: Record<string, string>;
+    description?: string;
+}
+/**
+ * Import operations for environments
+ */
+export interface IEnvironmentImporter {
+    importPostmanEnvironmentFile(filePath: string): ImportedEnvironment | null;
+}
+/**
+ * Read operations for environment configuration
+ */
+export interface IEnvironmentConfigReader {
+    getWorkspaceFolder(): string;
+    getRootPath(): string;
+    getEnvironmentNames(): string[];
+    getSelectedEnvironment(): string;
+    getSharedConfig(): SharedConfig | null;
+    getSharedConfigPath(): string;
+    getLocalConfig(): LocalConfig | null;
+    getLocalConfigPath(): string;
+    getEnvironmentConfigPath(envName: string): string;
+    getEnvLocalPath(envName: string): string;
+    getResolvedEnvironment(envName: string): ResolvedEnvironment | null;
+}
+/**
+ * Write operations for environment configuration
+ */
+export interface IEnvironmentConfigWriter {
+    saveSharedConfig(config: SharedConfig): void;
+    saveLocalConfig(config: LocalConfig): void;
+}
+/**
+ * Environment selection operations
+ */
+export interface IEnvironmentSelector {
+    setSelectedEnvironment(envName: string): Promise<void>;
+}
+/**
+ * Variable resolution operations
+ */
+export interface IVariableResolver {
+    resolveVariables(text: string, envName?: string): string;
+    resolveVariablesWithExtra(text: string, extraVariables: Record<string, string>, envName?: string): string;
+    resolveVariablesInObject<T extends Record<string, any>>(obj: T, envName?: string): T;
+    resolveVariablesInObjectWithExtra<T extends Record<string, any>>(obj: T, extraVariables: Record<string, string>, envName?: string): T;
+}
+/**
+ * Variable management operations (for scripts)
+ */
+export interface IVariableManager {
+    setEnvironmentVariable(key: string, value: unknown): void;
+    deleteEnvironmentVariable(key: string): void;
+    clearEnvironmentVariables(): void;
+    getEnvironmentVariableLocals(): Record<string, string>;
+    setGlobalVariable(key: string, value: unknown): void;
+    getGlobalVariable(key: string): string | undefined;
+    deleteGlobalVariable(key: string): void;
+    clearGlobalVariables(): void;
+    setSessionVariable(key: string, value: unknown): void;
+    deleteSessionVariable(key: string): Promise<void>;
+    clearSessionVariables(): Promise<void>;
+    getSessionVariables(): Record<string, string>;
+    getGlobalVariables(): Record<string, string>;
+}
+/**
+ * Full environment configuration service interface
+ */
+export interface IEnvironmentConfigService extends IEnvironmentConfigReader, IEnvironmentConfigWriter, IEnvironmentSelector, IVariableResolver, IVariableManager {
+    loadConfigs(): void;
+    exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+}
+/**
+ * Interface for storing and retrieving environment variables.
+ */
+export interface IEnvironmentStore {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    getAll(): Record<string, string>;
+    getActive(): string | undefined;
+    setActive(name: string): void;
+    getVariables(environmentName?: string): Record<string, string>;
+}
+/**
+ * Interface for interpolating variables in strings.
+ * Handles {{variable}} syntax replacement.
+ * @deprecated Use IVariableResolver for environment-aware resolution
+ */
+export interface IVariableInterpolator {
+    interpolate(input: string, variables: Record<string, string>): string;
+    extractVariables(input: string): string[];
+    interpolateObject<T>(obj: T, variables: Record<string, string>): T;
+}

package/dist/environment/variable-interpolator.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Variable Interpolator / Resolver
+ *
+ * Single Responsibility: Resolve template variables in strings and objects
+ *
+ * Features:
+ * - Regular variable substitution ({{myVar}} → value)
+ * - Dynamic variables ({{$timestamp}}, {{$randomInt(1, 100)}}, etc.)
+ * - Pipe-based filters (Thunder Client-compatible): {{variable | upper | replace("a", "b")}}
+ * - JavaScript expression evaluation: {{price * quantity}}
+ * - Context-aware escaping (avoids breaking quoted strings)
+ * - Extra variables with highest precedence
+ * - Recursive object traversal
+ * - Generic type preservation for object interpolation
+ *
+ * Resolution order (5-step pipeline):
+ * 1. $dynamic variables: {{$guid}}, {{$randomInt(1, 100)}}
+ * 2. Filter chains: {{myVar | upper | substring(0, 5)}}
+ * 3. Simple variable lookup: {{myVar}}
+ * 4. JavaScript expressions: {{price * quantity + 10}}
+ * 5. Return original {{...}} if nothing matched
+ */
+import { IVariableInterpolator } from './interfaces';
+/**
+ * Configuration for variable resolution
+ */
+export interface VariableResolverConfig {
+    globals: Record<string, string>;
+    collectionVariables: Record<string, string>;
+    environmentVariables: Record<string, string>;
+    sessionVariables: Record<string, string>;
+    variables: Record<string, string>;
+}
+/**
+ * Variable Resolver - Resolves {{varName}} patterns in strings and objects
+ * Uses a 5-step pipeline: $dynamic → filter chains → simple lookup → JS expressions → passthrough
+ * Variable precedence: globals > collection > environment > session > request > extra
+ */
+export declare class VariableResolver {
+    private readonly allVariables;
+    constructor(config: VariableResolverConfig);
+    /**
+     * Resolve variables in a string ({{varName}} syntax)
+     * Uses the full 5-step pipeline with optional escaping for quoted strings
+     */
+    resolveString(str: string, escape?: boolean): string;
+    /**
+     * Resolve variables in a string with additional extra variables
+     * Extra variables take highest precedence
+     */
+    resolveStringWithExtra(str: string, extraVariables: Record<string, string>, escape?: boolean): string;
+    /**
+     * Resolve variables in an object recursively
+     */
+    resolveObject(obj: any, escape?: boolean): any;
+    /**
+     * Resolve variables in an object with extra variables
+     */
+    resolveObjectWithExtra(obj: any, extraVariables: Record<string, string>, escape?: boolean): any;
+    /**
+     * Core 5-step resolution pipeline for template content inside {{ }}
+     */
+    private resolveTemplateContent;
+    /**
+     * Resolve the input portion of a filter chain
+     * Handles: @ (no-input), string literals, $dynamic variable, variable name, JS expression
+     */
+    private resolveFilterInput;
+    /**
+     * Escape special characters for string context
+     */
+    private escapeForString;
+    /**
+     * Determine if position is inside a quoted string and which quote type
+     */
+    private getStringContext;
+}
+/**
+ * VariableInterpolator — backward-compatible wrapper around VariableResolver
+ * Implements IVariableInterpolator interface using the 5-step resolution pipeline
+ */
+export declare class VariableInterpolator implements IVariableInterpolator {
+    /**
+     * Replace {{variable}} placeholders with values using the 5-step pipeline
+     * Automatically escapes values when inside quoted strings
+     */
+    interpolate(input: string, variables: Record<string, string>): string;
+    /**
+     * Extract variable names from a string
+     */
+    extractVariables(input: string): string[];
+    /**
+     * Replace variables in all string values of an object (recursive)
+     */
+    interpolateObject<T>(obj: T, variables: Record<string, string>): T;
+}
+/**
+ * Create a variable resolver from configuration
+ */
+export declare function createVariableResolver(config: VariableResolverConfig): VariableResolver;

package/dist/execution/collection-request-executor-interfaces.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Collection Request Executor Interface
+ *
+ * Defines the contract for executing a single collection request with full Postman parity:
+ * - Script execution order: Collection → Folder(s) → Request (pre-request)
+ * - Script execution order: Request → Folder(s) → Collection (post-response)
+ * - Supports nested folder scripts (multiple levels)
+ * - JavaScript variables declared in pre-request are accessible in post-response (shared VM session)
+ */
+import { ExecutionRequest, ExecutionResult } from '../types/types';
+/**
+ * Console output streaming callback
+ */
+export type ConsoleOutputCallback = (output: string[]) => void;
+/**
+ * Collection Request Executor Interface
+ *
+ * Executes a single request within a collection context, with full
+ * pre-request/post-response script chain support.
+ */
+export interface ICollectionRequestExecutor {
+    /**
+     * Execute a request with full Postman parity.
+     *
+     * Flow:
+     *   Collection pre-request → Folder(s) pre-request → Request pre-request
+     *   → HTTP call →
+     *   Request post-response → Folder(s) post-response → Collection post-response
+     *
+     * @param request - The request to execute
+     * @param variables - Current variable context (may include data file variables)
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns ExecutionResult with response, assertions, timing, etc.
+     */
+    execute(request: ExecutionRequest, variables: Record<string, string>, signal?: AbortSignal): Promise<ExecutionResult>;
+}