@http-forge/core 0.2.0 → 0.2.2

package/dist/application/use-cases/export-collection.use-case.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Export Collection Use Case
+ */
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { IFileSystem } from '../../ports/external/file-system.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { ExportCollectionInput } from '../dto/request-dtos';
+import { ExportCollectionOutput } from '../dto/response-dtos';
+export type { ExportCollectionInput } from '../dto/request-dtos';
+export declare class ExportCollectionUseCase {
+    private collectionRepository;
+    private fileSystem;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, fileSystem: IFileSystem, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: ExportCollectionInput): Promise<ExportCollectionOutput>;
+    private toPostman;
+    private toOpenAPI;
+    private convertItems;
+    private extractPaths;
+}

package/dist/application/use-cases/get-collection.use-case.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get Collection Use Case
+ */
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { GetCollectionInput } from '../dto/request-dtos';
+import { GetCollectionOutput } from '../dto/response-dtos';
+export declare class GetCollectionUseCase {
+    private collectionRepository;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, logger: ILogger);
+    execute(input: GetCollectionInput): Promise<GetCollectionOutput>;
+}

package/dist/application/use-cases/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Application Use Cases
+ */
+export * from './execute-request.use-case';
+export * from './load-collection.use-case';
+export * from './save-collection.use-case';
+export * from './create-request.use-case';
+export * from './update-request.use-case';
+export * from './delete-request.use-case';
+export * from './list-requests.use-case';
+export * from './get-collection.use-case';
+export * from './export-collection.use-case';

package/dist/application/use-cases/list-requests.use-case.d.ts

@@ -0,0 +1,14 @@
+/**
+ * List Requests Use Case
+ */
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ListRequestsInput } from '../dto/request-dtos';
+import { ListRequestsOutput } from '../dto/response-dtos';
+export declare class ListRequestsUseCase {
+    private collectionRepository;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, logger: ILogger);
+    execute(input: ListRequestsInput): Promise<ListRequestsOutput>;
+    private collectRequests;
+}

package/dist/application/use-cases/load-collection.use-case.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Load Collection Use Case
+ *
+ * Loads a collection from file and parses it
+ * Returns FULL collection with ALL metadata preserved (headers, query, scripts, etc.)
+ */
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { IFileSystem } from '../../ports/external/file-system.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ICollectionParser } from '../../ports/parsers/collection-parser.interface';
+import { LoadCollectionInput } from '../dto/request-dtos';
+import { LoadCollectionOutput } from '../dto/response-dtos';
+/**
+ * Use Case: Load collection from file
+ */
+export declare class LoadCollectionUseCase {
+    private fileSystem;
+    private collectionParser;
+    private eventPublisher;
+    private logger;
+    constructor(fileSystem: IFileSystem, collectionParser: ICollectionParser, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    /**
+     * Load collection from file path
+     */
+    execute(input: LoadCollectionInput): Promise<LoadCollectionOutput>;
+    /**
+     * Count total requests recursively
+     */
+    private countRequests;
+}

package/dist/application/use-cases/save-collection.use-case.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Save Collection Use Case
+ *
+ * Saves a collection to file
+ */
+import { IFileSystem } from '../../ports/external/file-system.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { SaveCollectionInput } from '../dto/request-dtos';
+import { SaveCollectionOutput } from '../dto/response-dtos';
+/**
+ * Use Case: Save collection to file
+ */
+export declare class SaveCollectionUseCase {
+    private fileSystem;
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(fileSystem: IFileSystem, collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    /**
+     * Save collection to file
+     */
+    execute(input: SaveCollectionInput): Promise<SaveCollectionOutput>;
+}

package/dist/application/use-cases/update-request.use-case.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Update Request Use Case
+ * Supports updating all request fields including enabled/disabled headers and schemas
+ */
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { UpdateRequestInput } from '../dto/request-dtos';
+import { UpdateRequestOutput } from '../dto/response-dtos';
+export type { UpdateRequestInput } from '../dto/request-dtos';
+export declare class UpdateRequestUseCase {
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: UpdateRequestInput): Promise<UpdateRequestOutput>;
+}

package/dist/container.d.ts

@@ -1,23 +1,40 @@
 /**
  * Forge Container - Dependency Injection Container
  *
+ * ⚠️ @deprecated 此类用于向后兼容
+ * 新代码应使用 infrastructure/di/complete-bootstrap 中的 bootstrapComplete() 函数
+ *
+ * 向后兼容层:
+ * 此文件继续提供原有的 ForgeContainer 接口
+ * 内部实现现已迁移至三层架构 (Domain/Application/Infrastructure)
+ *
+ * 迁移指南:
+ * 旧代码:
+ *   const container = new ForgeContainer(config);
+ *
+ * 新代码:
+ *   import { ServiceContainer } from '@http-forge/core/di';
+ *   import { bootstrapComplete } from '@http-forge/core/infrastructure/di';
+ *
+ *   const container = new ServiceContainer();
+ *   bootstrapComplete(container, { useFileSystem: true });
+ *
  * Single Responsibility: Wire up all components with proper dependencies
  * Factory Pattern: Creates configured instances of services
  */
-import { ICookieService } from './cookie/interfaces';
-import { IDataFileParser } from './platform/data-file-parser';
-import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './http/interceptor-chain';
-import { IRequestPreprocessor } from './http/request-preprocessor';
+import { ParserRegistry } from './infrastructure/collection/parser-registry';
+import { ICookieService } from './infrastructure/cookie/interfaces';
+import { EnvironmentResolver, EnvironmentStoreConfig } from './infrastructure/environment/environment-resolver';
+import { ForgeEnv } from './infrastructure/environment/forge-env';
+import { IVariableInterpolator } from './types/environment-config';
+import { RequestExecutor } from './infrastructure/execution/request-executor';
+import { IRequestHistory } from './infrastructure/history/history-interfaces';
+import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './infrastructure/http/interceptor-chain';
+import { IRequestPreprocessor } from './infrastructure/http/request-preprocessor';
+import { IDataFileParser } from './infrastructure/platform/data-file-parser';
+import { IScriptExecutor } from './infrastructure/script/interfaces';
 import { IFileSystem, IHttpClient } from './types/platform';
-import { ICollectionLoader } from './collection/interfaces';
-import { IRequestHistory } from './history/history-interfaces';
-import { IScriptExecutor } from './script/interfaces';
-import { IVariableInterpolator } from './environment/interfaces';
 import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './types/types';
-import { EnvironmentResolver, EnvironmentStoreConfig } from './environment/environment-resolver';
-import { ForgeEnv } from './environment/forge-env';
-import { ParserRegistry } from './collection/parser-registry';
-import { RequestExecutor } from './execution/request-executor';
 /**
  * Container configuration options
  */
@@ -92,7 +109,7 @@ export declare class ForgeContainer {
     readonly dataFileParser: IDataFileParser;
     readonly requestHistory: IRequestHistory | null;
     readonly parserRegistry: ParserRegistry;
-    readonly collectionLoader: ICollectionLoader;
+    readonly collectionLoader: import('./types/collection').ICollectionLoader;
     readonly environmentStore: EnvironmentResolver;
     readonly forgeEnv: ForgeEnv;
     readonly requestExecutor: RequestExecutor;
@@ -135,18 +152,17 @@ export declare class ForgeContainer {
     /**
      * Create a container by auto-loading environments from forgeRoot
      *
-     * Reads `{forgeRoot}/environments/environments.json` and creates
-     * a container with the environment configuration pre-loaded.
+     * Reads the multi-file environment folder format under
+     * `{forgeRoot}/environments/` (same format used by the VS Code extension).
+     * Falls back to the legacy single-file `environments.json` when the
+     * multi-file format is not detected.
      *
      * @param forgeRoot - Path to http-forge folder (default: './http-forge')
      * @param options - Additional container options
      *
      * @example
      * ```typescript
-     * // Auto-load environments from ./http-forge/environments/environments.json
      * const forge = ForgeContainer.fromForgeRoot('./http-forge');
-     *
-     * // Switch environment
      * forge.forgeEnv.setActiveEnvironment('sit');
      * ```
      */

package/dist/di/core-bootstrap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core Service Bootstrap
+ *
+ * Registers all platform-agnostic services in the ServiceContainer.
+ * The host environment (VS Code, CLI, etc.) only needs to provide
+ * PlatformAdapters — the actual service wiring lives here.
+ *
+ * This is the single source of truth for service dependencies.
+ */
+import type { PlatformAdapters } from './platform-adapters';
+import type { ServiceContainer } from './service-container';
+/**
+ * Register all platform-agnostic core services in the container.
+ *
+ * @param container - The service container to register into
+ * @param adapters - Platform-specific adapters provided by the host
+ *
+ * @example
+ * ```typescript
+ * const container = ServiceContainer.instance;
+ * container.clear();
+ * registerCoreServices(container, adapters);
+ * ```
+ */
+export declare function registerCoreServices(container: ServiceContainer, adapters: PlatformAdapters): void;

package/dist/di/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dependency Injection
+ *
+ * ⚠️ @deprecated 此模块用于向后兼容
+ * 新代码应使用 infrastructure/di/complete-bootstrap 中的功能
+ *
+ * Provides a generic, platform-agnostic DI container and service bootstrap.
+ * Host environments (VS Code, CLI, etc.) only need to supply PlatformAdapters.
+ *
+ * 迁移指南:
+ * - 旧的 ServiceContainer 已被新的架构集成
+ * - 使用 bootstrapComplete() 替代 registerCoreServices()
+ * - 详见 ARCHITECTURE_IMPLEMENTATION.md
+ */
+export { registerCoreServices } from './core-bootstrap';
+export type { PlatformAdapters } from './platform-adapters';
+export { getServiceContainer, ServiceContainer } from './service-container';
+export { ServiceIdentifiers } from './service-identifiers';
+export type { ServiceIdentifier } from './service-identifiers';

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

@@ -0,0 +1,66 @@
+/**
+ * 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, IFileSystem, IFileWatcherFactory, IHttpClient, IKeyValueStore, INotificationService, ISecretStore } from '../types/platform';
+import type { IHttpExecutor } from '../ports/executors/http-executor.interface';
+import type { IScriptExecutor } from '../ports/executors/script-executor.interface';
+import type { ILogger } from '../ports/external/logger.interface';
+/**
+ * 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;
+    /** File system adapter */
+    fileSystem?: IFileSystem;
+    /** Logger adapter */
+    logger?: ILogger;
+    /** HTTP client adapter */
+    httpClient?: IHttpClient;
+    /** HTTP executor adapter */
+    httpExecutor?: IHttpExecutor;
+    /** Script executor adapter */
+    scriptExecutor?: IScriptExecutor;
+}

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 '../infrastructure/cookie/interfaces';
+import type { IRequestPreparer } from '../infrastructure/execution/request-preparer-interfaces';
+import type { IRequestHistoryService } from '../infrastructure/history/request-history-service-interfaces';
+import type { IHttpRequestService } from '../infrastructure/http/interfaces';
+import type { IScriptExecutor } from '../infrastructure/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 '../infrastructure/auth/interfaces';
+import type { ICollectionService } from '../types/collection';
+import type { IConfigService } from '../infrastructure/config';
+import type { IEnvironmentConfigService } from '../types/environment-config';
+import type { IGraphQLSchemaService } from '../infrastructure/graphql/graphql-schema-service';
+import type { IDataFileParser } from '../infrastructure/platform/data-file-parser';
+import type { ICookieJar } from '../infrastructure/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] | string;

package/dist/domain/errors/domain-errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Domain Errors - Business-specific exceptions
+ *
+ * Use these instead of generic Error for domain-level problems
+ */
+/**
+ * Base domain error
+ */
+export declare class DomainError extends Error {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: Record<string, any> | undefined;
+    constructor(code: string, message: string, details?: Record<string, any> | undefined);
+}
+/**
+ * Collection not found
+ */
+export declare class CollectionNotFoundError extends DomainError {
+    constructor(collectionId: string);
+}
+/**
+ * Request not found
+ */
+export declare class RequestNotFoundError extends DomainError {
+    constructor(requestId: string);
+}
+/**
+ * Invalid request - validation failed
+ */
+export declare class InvalidRequestError extends DomainError {
+    constructor(message: string);
+    constructor(requestId: string, reason: string);
+}
+/**
+ * Execution failed - HTTP or script error
+ */
+export declare class ExecutionError extends DomainError {
+    readonly originalError?: Error | undefined;
+    constructor(requestId: string, reason: string, originalError?: Error | undefined);
+}
+/**
+ * Script error - pre/post script failed
+ */
+export declare class ScriptExecutionError extends DomainError {
+    constructor(requestId: string, stage: 'pre' | 'post', reason: string);
+}
+/**
+ * Variable interpolation failed
+ */
+export declare class VariableResolutionError extends DomainError {
+    constructor(variableName: string, reason: string);
+}

package/dist/domain/errors/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain Errors - Business exceptions
+ */
+export * from './domain-errors';

package/dist/domain/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Domain Layer - Business logic (Clean Architecture)
+ *
+ * Contains:
+ * - Domain models (pure data structures)
+ * - Domain services (pure business logic)
+ * - Domain errors (business exceptions)
+ * - Domain events (event publishing)
+ *
+ * Constraints:
+ * - ZERO external dependencies
+ * - NO platform-specific code
+ * - NO persistence concerns
+ * - Fully testable without mocks
+ *
+ * Usage:
+ * - Imported by application layer
+ * - Used for business rule validation
+ * - Should be framework-agnostic
+ */
+export * from './models';
+export * from './services';
+export * from './errors';
+export * from './value-objects';

package/dist/domain/models/execution.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Execution Domain Models - Core execution data structures
+ *
+ * These are pure domain models independent of storage or UI concerns
+ */
+import { HttpRequest, HttpResponse } from '../../types/types';
+/**
+ * Execution context - captures state during request execution
+ */
+export interface IExecutionContext {
+    requestId: string;
+    collectionId: string;
+    variables: Record<string, any>;
+    environment: Record<string, any>;
+    cookies: Record<string, string>;
+    metadata?: {
+        userId?: string;
+        timestamp?: Date;
+        [key: string]: any;
+    };
+}
+/**
+ * Execution plan - describes how to execute a request
+ */
+export interface IExecutionPlan {
+    requestId: string;
+    request: HttpRequest;
+    preScripts?: string[];
+    postScripts?: string[];
+    scripts?: {
+        preRequest?: string;
+        postResponse?: string;
+    };
+}
+/**
+ * Execution result - outcome of request execution
+ */
+export interface IExecutionResult {
+    /** Request ID */
+    requestId: string;
+    /** HTTP response */
+    response: HttpResponse;
+    /** Execution time (ms) */
+    duration: number;
+    /** Pre-request script result */
+    preScriptResult?: {
+        success: boolean;
+        output: any;
+        errors: string[];
+    };
+    /** Post-response script result */
+    postScriptResult?: {
+        success: boolean;
+        output: any;
+        errors: string[];
+        assertions?: AssertionResult[];
+    };
+    /** Variable changes during execution */
+    variableChanges?: Record<string, any>;
+    /** Execution status */
+    status: 'success' | 'failed' | 'partial';
+    /** Error message if execution failed */
+    error?: string;
+}
+/**
+ * Test assertion result
+ */
+export interface AssertionResult {
+    name: string;
+    passed: boolean;
+    expected: any;
+    actual: any;
+    message?: string;
+}
+/**
+ * Execution metrics
+ */
+export interface IExecutionMetrics {
+    requestId: string;
+    duration: number;
+    httpStatus: number;
+    success: boolean;
+    timestamp: Date;
+    size?: {
+        requestBytes?: number;
+        responseBytes?: number;
+    };
+}

package/dist/domain/models/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain Models - Core business data structures
+ */
+export * from './execution';