@http-forge/core 0.2.0 → 0.2.2

package/dist/infrastructure/adapters/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * External Adapters
+ */
+export * from './node-file-system.adapter';
+export * from './logger.adapter';

package/dist/infrastructure/adapters/logger.adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Console Logger Adapter - ILogger implementation
+ */
+import { ILogger, LogLevel } from '../../ports/external/logger.interface';
+/**
+ * Simple console-based logger implementation
+ */
+export declare class ConsoleLoggerAdapter implements ILogger {
+    private minLevel;
+    constructor(minLevel?: LogLevel);
+    debug(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, error?: Error | Record<string, any>): void;
+    private canLog;
+}
+/**
+ * Silent logger - no output
+ */
+export declare class SilentLoggerAdapter implements ILogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/infrastructure/adapters/node-file-system.adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Node File System Adapter - IFileSystem implementation for Node.js
+ */
+import { IFileSystem, FileStat } from '../../ports/external/file-system.interface';
+/**
+ * Node.js implementation of IFileSystem
+ */
+export declare class NodeFileSystemAdapter implements IFileSystem {
+    exists(path: string): Promise<boolean>;
+    readFile(filePath: string): Promise<string>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    readDir(dirPath: string): Promise<string[]>;
+    mkdir(dirPath: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    delete(filePath: string): Promise<void>;
+    stat(filePath: string): Promise<FileStat>;
+}

package/dist/{auth → infrastructure/auth}/interfaces.d.ts

@@ -8,7 +8,7 @@
  * CLI/Standalone impl: uses system browser + local HTTP callback server
  * Browser impl: uses window.open() + postMessage
  */
-import { OAuth2Config } from '../types/types';
+import { OAuth2Config } from '../../types/types';
 export interface TokenInfo {
     accessToken: string;
     /** e.g. "Bearer" */

package/dist/{auth → infrastructure/auth}/oauth2-token-manager.d.ts

@@ -13,11 +13,11 @@
  * Platform-specific behaviour (browser opening, secret storage, callback URIs)
  * is injected via IExternalBrowserService and ISecretStore interfaces.
  */
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { IEnvironmentConfigService } from '../../types/environment-config';
 import { IHttpRequestService } from '../http/interfaces';
+import { IExternalBrowserService, ISecretStore } from '../../types/platform';
+import { OAuth2Config } from '../../types/types';
 import { IOAuth2TokenManager, TokenCacheKey, TokenInfo } from './interfaces';
-import { IExternalBrowserService, ISecretStore } from '../types/platform';
-import { OAuth2Config } from '../types/types';
 export declare class OAuth2TokenManager implements IOAuth2TokenManager {
     private readonly secretStore;
     private readonly browserService;

package/dist/{collection → infrastructure/collection}/collection-loader.d.ts

@@ -4,9 +4,9 @@
  * Single Responsibility: Load collections from file system
  * Dependency Inversion: Uses IFileSystem and ParserRegistry abstractions
  */
-import { IFileSystem } from '../types/platform';
-import { UnifiedCollection } from '../types/types';
-import { ICollectionLoader } from './interfaces';
+import { IFileSystem } from '../../types/platform';
+import { UnifiedCollection } from '../../types/types';
+import type { ICollectionLoader } from '../../types/collection';
 import { ParserRegistry } from './parser-registry';
 /**
  * Options for loading a collection

package/dist/{collection → infrastructure/collection}/collection-service.d.ts

@@ -8,9 +8,9 @@
  * - ConfigService for configuration
  * - CollectionLoader for storage abstraction (supports folder and json formats)
  */
-import { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from './collection-service-interfaces';
-import { IFileWatcherFactory } from '../types/platform';
 import { IConfigService } from '../config';
+import { IFileWatcherFactory } from '../../types/platform';
+import type { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from '../../types/collection';
 /**
  * Service for managing HTTP Forge collections
  */

package/dist/{collection → infrastructure/collection}/collection-store.d.ts

@@ -6,8 +6,8 @@
  * - JsonCollectionLoader: Loads from single JSON files
  * - FolderCollectionStore: Loads from directory structure
  */
-import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
-import type { CollectionRequest } from '../types/types';
+import type { CollectionRequest } from '../../types/types';
+import type { Collection, CollectionItem, RequestScripts } from '../../types/collection';
 /**
  * Rich interface for loading, saving, and managing collections
  */

package/dist/infrastructure/collection/folder-collection-loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Folder Collection Loader
+ *
+ * Thin adapter around FolderCollectionStore that converts between the
+ * `Collection` / `CollectionItem` types (array-based headers/query with
+ * `enabled` flag) and the simpler `UnifiedCollection` / `UnifiedRequest`
+ * types (Record-based headers/query) used by ForgeContainer.
+ *
+ * All disk I/O is delegated to FolderCollectionStore — this class only
+ * performs type conversion on the way in and out.
+ */
+import type { CollectionScripts, UnifiedCollection, UnifiedFolder, UnifiedRequest } from '../../types/types';
+import type { CollectionMetadata } from './collection-store';
+import type { ICollectionLoader } from '../../types/collection';
+export { generateSlug } from './folder-io';
+type UnifiedItem = UnifiedFolder | UnifiedRequest;
+/**
+ * Folder Collection Loader
+ *
+ * Implements `ICollectionLoader` and exposes CRUD using `UnifiedCollection` /
+ * `UnifiedRequest` types. All disk I/O is handled by the underlying
+ * `FolderCollectionStore`; this class converts types on the boundary.
+ */
+export declare class FolderCollectionLoader implements ICollectionLoader {
+    /** The underlying canonical store that handles all disk I/O */
+    private readonly store;
+    constructor(collectionsDir: string);
+    loadAll(): UnifiedCollection[];
+    getSlugById(id: string): string | undefined;
+    getIdBySlug(slug: string): string | undefined;
+    load(id: string): UnifiedCollection | undefined;
+    create(name: string, id?: string): Promise<UnifiedCollection>;
+    save(collection: UnifiedCollection): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): boolean;
+    getCollectionPath(id: string): string;
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    saveItem(collectionId: string, item: UnifiedItem, parentId?: string): Promise<void>;
+    updateItem(collectionId: string, itemId: string, updates: Partial<UnifiedItem>): Promise<boolean>;
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    saveScripts(collectionId: string, itemId: string, scripts: CollectionScripts): Promise<void>;
+    loadScripts(collectionId: string, itemId: string): CollectionScripts | undefined;
+}

package/dist/{collection → infrastructure/collection}/folder-collection-store.d.ts

@@ -12,7 +12,7 @@
  *
  * Ported from the VS Code extension's FolderCollectionLoader.
  */
-import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { Collection, CollectionItem, RequestScripts } from '../../types/collection';
 import type { CollectionMetadata, ICollectionStore } from './collection-store';
 /**
  * Loads and manages collections from folder structure using Collection types.
@@ -37,6 +37,14 @@ export declare class FolderCollectionStore implements ICollectionStore {
     private slugToIdMap;
     private idToSlugMap;
     constructor(collectionsDir: string);
+    /**
+     * Get collection/item slug from ID
+     */
+    getSlugById(id: string): string | undefined;
+    /**
+     * Get collection/item ID from slug
+     */
+    getIdBySlug(slug: string): string | undefined;
     /**
      * Ensure collections directory exists
      */
@@ -162,7 +170,6 @@ export declare class FolderCollectionStore implements ICollectionStore {
      */
     private sortItemsByOrder;
     private findItemPath;
-    private searchForItemPath;
     private findItemById;
     private deleteItemFromTree;
 }

package/dist/infrastructure/collection/folder-io.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Folder Format I/O Primitives
+ *
+ * Shared file I/O operations for the folder-based collection storage format.
+ * Used by both FolderCollectionLoader (read-only, UnifiedCollection types)
+ * and FolderCollectionStore (full CRUD, Collection types).
+ *
+ * Eliminates ~200 lines of duplicated code between the two implementations.
+ */
+import type { RequestBody } from '../../types/types';
+/** Script file names within a scripts/ directory */
+export declare const SCRIPT_FILES: {
+    preRequest: string;
+    postResponse: string;
+};
+/** Metadata file names that identify item types */
+export declare const METADATA_FILES: {
+    collection: string;
+    folder: string;
+    request: string;
+};
+/**
+ * Body file extensions mapped to body type/format.
+ * Files stored externally get syntax highlighting benefits.
+ * Other types (form-data, urlencoded, binary, none) stay in request.json.
+ */
+export declare const BODY_FILE_MAP: Record<string, {
+    type: 'raw' | 'graphql';
+    format?: 'json' | 'text' | 'xml' | 'html' | 'javascript';
+}>;
+/** Schema files stored alongside request.json for OpenAPI round-trip support */
+export declare const SCHEMA_FILES: {
+    responseSchema: string;
+    bodySchema: string;
+};
+/** Scripts directory name */
+export declare const SCRIPTS_DIR = "scripts";
+/**
+ * Scripts structure (shared shape between CollectionScripts and RequestScripts)
+ */
+export interface ScriptsData {
+    preRequest?: string;
+    postResponse?: string;
+}
+/**
+ * Read scripts from a scripts/ directory.
+ * Returns undefined if the directory doesn't exist or has no scripts.
+ */
+export declare function readScriptsFromDir(scriptsPath: string): ScriptsData | undefined;
+/**
+ * Write scripts to a scripts/ directory.
+ */
+export declare function writeScriptsToDir(scriptsPath: string, scripts: ScriptsData): Promise<void>;
+/**
+ * Load body from external file if present.
+ * Supports: body.json, body.xml, body.txt, body.html, body.js, body.graphql
+ */
+export declare function readBodyFromDir(requestPath: string): RequestBody | undefined;
+/**
+ * Separate body content into metadata-inline vs. external-file parts.
+ */
+export declare function prepareBodyForSave(body: any): {
+    bodyForMetadata: any;
+    externalBodyFile?: {
+        filename: string;
+        content: string;
+    };
+};
+/**
+ * Remove stale body files that don't match the current format.
+ */
+export declare function cleanupOldBodyFiles(requestPath: string, currentBodyFile?: string): Promise<void>;
+/**
+ * Load a JSON schema file if it exists.
+ * Returns the parsed object or undefined.
+ */
+export declare function readSchemaFile(filePath: string): any | undefined;
+/**
+ * Save OpenAPI schema files (response.schema.json, body.schema.json).
+ */
+export declare function writeSchemaFiles(requestPath: string, responseSchema?: any, bodySchema?: any): Promise<void>;
+/** Minimal interface for tree traversal — both UnifiedFolder/UnifiedRequest and CollectionItem satisfy this */
+interface TreeNode {
+    id: string;
+    type: string;
+    items?: TreeNode[];
+}
+/**
+ * Find an item by ID in a tree (recursive).
+ */
+export declare function findItemById<T extends TreeNode>(items: T[], id: string): T | undefined;
+/**
+ * Remove an item from a tree by ID (mutates the array).
+ */
+export declare function deleteItemFromTree<T extends TreeNode>(items: T[], id: string): boolean;
+/**
+ * Re-sort items to match an ordered list of IDs.
+ * Items not in orderedIds are appended at the end.
+ */
+export declare function sortItemsByOrder<T extends {
+    id: string;
+}>(items: T[], orderedIds: string[]): T[];
+/**
+ * Recursively search for a directory named targetSlug under basePath.
+ */
+export declare function searchForItemPath(basePath: string, targetSlug: string): string | undefined;
+/**
+ * Generate a slug from a name.
+ * Handles HTTP method prefixes, version indicators (T7, 1.5), path parameters,
+ * and deduplication with counter suffixes.
+ */
+export declare function generateSlug(name: string, existingSlugs?: string[]): string;
+export {};

package/dist/{collection → infrastructure/collection}/json-collection-loader.d.ts

@@ -7,7 +7,7 @@
  * For JSON format, all item-level operations fall back to saving the entire collection
  * since everything is in one file anyway.
  */
-import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { Collection, CollectionItem, RequestScripts } from '../../types/collection';
 import type { CollectionMetadata, ICollectionStore } from './collection-store';
 /**
  * Loads collections from JSON files

package/dist/{collection → infrastructure/collection}/parser-registry.d.ts

@@ -4,7 +4,7 @@
  * Open/Closed Principle: New parsers can be added without modifying existing code
  * Single Responsibility: Manage collection parser registration and lookup
  */
-import { ICollectionParser } from './interfaces';
+import type { ICollectionParser } from '../../types/collection';
 /**
  * Registry for collection parsers
  * Allows registering parsers for different collection formats

package/dist/{config → infrastructure/config}/config-service.d.ts

@@ -7,7 +7,7 @@
  * Platform-agnostic — uses IFileWatcherFactory and INotificationService
  * instead of VS Code APIs.
  */
-import { IFileWatcherFactory, INotificationService } from '../types/platform';
+import { IFileWatcherFactory, INotificationService } from '../../types/platform';
 import type { EnvironmentsConfig, HttpForgeConfig, IConfigService, ProxyConfig, RequestConfig, RunnerConfig, ScriptsConfig, StorageConfig } from './config.interface';
 /**
  * Configuration Service Implementation

package/dist/{cookie → infrastructure/cookie}/cookie-service.d.ts

@@ -5,8 +5,8 @@
  * Platform-agnostic — uses IKeyValueStore for persistence
  * instead of VS Code globalState.
  */
+import { IKeyValueStore } from '../../types/platform';
 import { Cookie, ICookieParser, ICookieReader } from './interfaces';
-import { IKeyValueStore } from '../types/platform';
 /**
  * Full cookie service interface (async write operations for platform persistence)
  */

package/dist/infrastructure/di/complete-bootstrap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Complete Infrastructure Bootstrap
+ *
+ * Registers all infrastructure implementations including:
+ * - File system repositories
+ * - History loaders
+ * - HTTP/Script executors
+ * - Parsers
+ * - Adapters
+ */
+import { PlatformAdapters } from '../../di/platform-adapters';
+import { ServiceContainer } from '../../di/service-container';
+export interface FullBootstrapOptions {
+    /** Use file system repositories instead of in-memory */
+    useFileSystem?: boolean;
+    /** Base path for file system operations */
+    basePath?: string;
+    /** Platform adapters (file system, logger, HTTP client, etc) */
+    adapters?: Partial<PlatformAdapters>;
+}
+/**
+ * Complete bootstrap with all implementations
+ */
+export declare function bootstrapComplete(container: ServiceContainer, options?: FullBootstrapOptions): void;

package/dist/infrastructure/di/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dependency Injection Configuration
+ */
+export * from './infrastructure-di-config';
+export * from './simple-event-publisher';
+export * from './complete-bootstrap';

package/dist/infrastructure/di/infrastructure-di-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Infrastructure DI Configuration
+ *
+ * Registers all infrastructure implementations and wires up the dependency graph
+ *
+ * Usage:
+ * ```typescript
+ * const container = new ServiceContainer();
+ * registerInfrastructureServices(container);
+ * registerDomainServices(container);
+ * registerApplicationServices(container);
+ * ```
+ */
+import { ServiceContainer } from '../../di/service-container';
+import { PlatformAdapters } from '../../di/platform-adapters';
+/**
+ * Register infrastructure layer services
+ *
+ * These are concrete implementations of port interfaces
+ */
+export declare function registerInfrastructureServices(container: ServiceContainer, adapters?: Partial<PlatformAdapters>): void;
+/**
+ * Register domain layer services
+ */
+export declare function registerDomainServices(container: ServiceContainer): void;
+/**
+ * Register application layer services (use cases)
+ */
+export declare function registerApplicationServices(container: ServiceContainer): void;
+/**
+ * Bootstrap all layers
+ */
+export declare function bootstrapAllServices(container: ServiceContainer, adapters?: Partial<PlatformAdapters>): void;

package/dist/infrastructure/di/simple-event-publisher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Domain Event Publisher Implementation
+ */
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { DomainEvent } from '../../domain/services/domain-events';
+/**
+ * Simple in-memory event publisher
+ */
+export declare class SimpleEventPublisher implements IDomainEventPublisher {
+    private subscriptions;
+    publish(event: DomainEvent): Promise<void>;
+    subscribe(eventType: string, handler: (event: DomainEvent) => Promise<void>): void;
+    /**
+     * Clear all subscriptions (useful for testing)
+     */
+    clear(): void;
+}

package/dist/{environment → infrastructure/environment}/environment-config-service.d.ts

@@ -4,9 +4,9 @@
  * Platform-agnostic — uses IKeyValueStore for persistence instead of
  * VS Code's workspaceState/globalState.
  */
-import { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from './interfaces';
-import { IKeyValueStore } from '../types/platform';
 import { IConfigService } from '../config';
+import { IKeyValueStore } from '../../types/platform';
+import type { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from '../../types/environment-config';
 export declare class EnvironmentConfigService implements IEnvironmentConfigService {
     private workspaceFolder;
     private workspaceStore;
@@ -69,9 +69,12 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
     importPostmanEnvironmentFile(filePath: string): ImportedEnvironment;
     saveEnvLocalConfig(envName: string, variables: Record<string, string>): void;
     getEnvLocalPath(envName: string): string;
-    private isSystemEnvironmentFile;
     private getEnvLocalConfigPath;
     private loadFolderConfigs;
+    /**
+     * Create a VariableResolver pre-loaded with environment + session variables.
+     */
+    private createResolver;
     private saveFolderSharedConfig;
     reload(): void;
     getAllEnvironments(): Array<{

package/dist/infrastructure/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/{environment → infrastructure/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 type { IEnvironmentStore } from '../../types/environment-config';
 /**
  * Environment definition
  */

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

@@ -30,8 +30,8 @@
  * env.get('token');  // 'abc'
  * ```
  */
-import { IEnvironmentStore, IVariableInterpolator } from './interfaces';
 import { EnvironmentResolver } from './environment-resolver';
+import type { IEnvironmentStore, IVariableInterpolator } from '../../types/environment-config';
 /**
  * ForgeEnv interface - the public API for environment management
  */

package/dist/{environment → infrastructure/environment}/variable-interpolator.d.ts

@@ -20,7 +20,7 @@
  * 4. JavaScript expressions: {{price * quantity + 10}}
  * 5. Return original {{...}} if nothing matched
  */
-import { IVariableInterpolator } from './interfaces';
+import type { IVariableInterpolator } from '../../types/environment-config';
 /**
  * Configuration for variable resolution
  */

package/dist/{execution → infrastructure/execution}/collection-request-executor-interfaces.d.ts

@@ -7,7 +7,7 @@
  * - 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';
+import { ExecutionRequest, ExecutionResult } from '../../types/types';
 /**
  * Console output streaming callback
  */

package/dist/{execution → infrastructure/execution}/collection-request-executor.d.ts

@@ -10,11 +10,11 @@
  * Extracted from extension's request-execution/collection-request-executor.ts.
  * Platform-independent — no vscode dependency.
  */
-import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../types/types';
+import { IEnvironmentConfigService } from '../../types/environment-config';
+import { IHttpRequestService } from '../http/interfaces';
 import { ICookieJar, IScriptExecutor } from '../script/interfaces';
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../../types/types';
 import { ConsoleOutputCallback, ICollectionRequestExecutor } from './collection-request-executor-interfaces';
-import { IHttpRequestService } from '../http/interfaces';
 import { IRequestPreparer } from './request-preparer-interfaces';
 /**
  * Enhanced implementation with Postman parity.

package/dist/{execution → infrastructure/execution}/request-executor.d.ts

@@ -4,11 +4,11 @@
  * Single Responsibility: Orchestrate the complete request execution flow
  * Facade Pattern: Provides simplified interface to complex subsystem
  */
-import { IHttpClient } from '../types/platform';
-import { IScriptExecutor } from '../script/interfaces';
-import { IRequestPreprocessor } from '../http/request-preprocessor';
-import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../types/types';
 import { IForgeEnv } from '../environment/forge-env';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { IScriptExecutor } from '../script/interfaces';
+import { IHttpClient } from '../../types/platform';
+import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../../types/types';
 /**
  * Options for request execution
  */

package/dist/{execution → infrastructure/execution}/request-preparer-interfaces.d.ts

@@ -6,8 +6,8 @@
  *
  * Used by both Request Tester (manual) and Collection Runner (batch).
  */
-import { ResolvedEnvironment } from '../environment/interfaces';
-import { ExecutionRequest, PreparedRequest } from '../types/types';
+import { ResolvedEnvironment } from '../../types/environment-config';
+import { ExecutionRequest, PreparedRequest } from '../../types/types';
 /**
  * Request Preparer Service Interface
  *

package/dist/{execution → infrastructure/execution}/request-preparer.d.ts

@@ -9,12 +9,12 @@
  *
  * Used by both Request Tester (manual) and Collection Runner (batch).
  */
-import { IRequestPreprocessor } from '../http/request-preprocessor';
-import { ExecutionRequest, PreparedRequest } from '../types/types';
-import { IEnvironmentConfigService, ResolvedEnvironment } from '../environment/interfaces';
-import { IHttpRequestService } from '../http/interfaces';
 import { IOAuth2TokenManager } from '../auth/interfaces';
-import { IApplicationInfo } from '../types/platform';
+import { IEnvironmentConfigService, ResolvedEnvironment } from '../../types/environment-config';
+import { IHttpRequestService } from '../http/interfaces';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { IApplicationInfo } from '../../types/platform';
+import { ExecutionRequest, PreparedRequest } from '../../types/types';
 import { IRequestPreparer } from './request-preparer-interfaces';
 /**
  * RequestPreparer implementation

package/dist/{graphql → infrastructure/graphql}/graphql-schema-service.d.ts

@@ -12,7 +12,7 @@
  *
  * Zero Dependencies: Uses only the project's IHttpClient abstraction.
  */
-import { IHttpClient } from '../types/platform';
+import { IHttpClient } from '../../types/platform';
 export interface GraphQLField {
     name: string;
     type: string;

package/dist/{history → infrastructure/history}/history-interfaces.d.ts

@@ -4,7 +4,7 @@
  * Extracted from VS Code plugin: src/services/interfaces/request-history.interface.ts
  * Adapted for core package - storage-agnostic design
  */
-import { HttpRequest, HttpResponse, RequestBody } from '../types/types';
+import { HttpRequest, HttpResponse, RequestBody } from '../../types/types';
 /**
  * History entry - records a single request execution
  */

package/dist/{history → infrastructure/history}/request-history.d.ts

@@ -7,8 +7,8 @@
  * Based on VS Code plugin's RequestHistoryService logic,
  * but adapted for storage-agnostic design.
  */
+import { HttpRequest, HttpResponse } from '../../types/types';
 import { FullResponse, HistoryEntry, IRequestHistory } from './history-interfaces';
-import { HttpRequest, HttpResponse } from '../types/types';
 /**
  * In-memory request history storage
  *