@http-forge/core 0.2.0 → 0.2.2

package/README.md

@@ -11,11 +11,14 @@
 
 **Core Features:**
 - 🚀 **Postman Collections** - Load and execute `.postman_collection.json` and `.forge.json` files
-- 📝 **JavaScript Scripting** - Pre-request and post-response scripts with `pm.*` API (events, variables, assertions)
+- 📝 **JavaScript Scripting** - Pre-request and post-response scripts with full `pm.*` API (variables, assertions, execution flow, visualizer)
 - 🔄 **Dynamic Variables** - Built-in generators: `{{$randomInt}}`, `{{$timestamp}}`, `{{$uuid}}`, `{{$guid}}`, etc.
-- 🌍 **Environments** - Full variable scoping (globals, collection, environment, session, flow-level)
-- 🍪 **Cookie Persistence** - Automatic cookie storage and reuse across request sequences
-- 📊 **Test Assertions** - BDD-style testing with `pm.test()` and `expect()` chains
+- 🌍 **Environments** - Full variable scoping (globals, collection, environment, session, iterationData)
+- 🍪 **Cookie Persistence** - Automatic cookie storage and reuse, `pm.cookies.jar()` and `.toObject()`
+- 📊 **Test Assertions** - BDD-style testing with `pm.test()` (sync/async) and full Chai `expect()` chains
+- 🔐 **CryptoJS** - Full crypto library: hash, HMAC, AES/DES/TripleDES, PBKDF2, encoding helpers
+- 🎯 **Execution Flow** - `pm.setNextRequest()`, `pm.execution.skipRequest()` for suite runner flow control
+- 📈 **Visualizer** - `pm.visualizer.set(template, data)` for custom Handlebars-based HTML output
 - 🔌 **Extensible** - Custom interceptors, HTTP clients, and module loaders
 
 **Ideal for:**
@@ -634,6 +637,24 @@ MIT © Henry Huang
 
 ## 📝 Changelog
 
+### 0.2.0 (Postman API Parity)
+
+- ✅ **Async `pm.test()` support** - Tests with async callbacks are properly awaited
+- ✅ **Expect chain assertions** - `.a(type)`, `.an(type)`, `.deep.equal()`, `.lengthOf()`, `.exist`, `.members()`, `.keys()`, `.string()`
+- ✅ **`pm.iterationData`** scope - Data-driven testing with iteration variables
+- ✅ **Response status getters** - `response.to.be.ok`, `.error`, `.clientError`, `.serverError` work as getters and functions
+- ✅ **Response headers HeaderList** - `.get()`, `.has()`, `.toObject()`, `.each()` on `pm.response.headers`
+- ✅ **`pm.cookies.toObject()`** - Flat `{name: value}` cookie map
+- ✅ **`replaceIn()` on all scopes** - Available on `pm.variables`, `pm.environment`, `pm.collectionVariables`, `pm.globals`
+- ✅ **Sandbox globals** - `xml2Json()`, `jsonStringify()`, `jsonParse()` available in scripts
+- ✅ **Request headers API** - `.toObject()`, `.each()` on `pm.request.headers`
+- ✅ **`pm.execution.setNextRequest()`** - Runner flow control (jump to named request or stop with `null`)
+- ✅ **`pm.execution.skipRequest()`** - Skip HTTP call from pre-request scripts
+- ✅ **`pm.setNextRequest()`** - Top-level alias for flow control
+- ✅ **`pm.visualizer.set(template, data)`** - Custom HTML visualization with Handlebars templates
+- ✅ **`pm.request.url` as Url object** - Postman SDK-compatible Url with `getHost()`, `getPath()`, `getQueryString()`, `protocol`, `host`, `port`, `path`, `query`, `hash`
+- ✅ **Full CryptoJS** - AES/DES/TripleDES encrypt/decrypt, PBKDF2, all hash algorithms (SHA1/256/384/512/SHA3/MD5/RIPEMD160), HMAC, encoding helpers (Hex/Base64/Utf8/Latin1/Utf16)
+
 ### 0.1.0 (Initial Release)
 
 - ✅ **Core request execution** with Postman collection support

package/dist/application/dto/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Application DTOs
+ *
+ * Data Transfer Objects decouple use-case inputs/outputs
+ * from domain internals and infrastructure types.
+ */
+export type { CreateRequestInput, UpdateRequestInput, DeleteRequestInput, ListRequestsInput, GetCollectionInput, ExecuteRequestInput, LoadCollectionInput, SaveCollectionInput, ExportCollectionInput, GetRequestSchemaInput, ExportFormat, } from './request-dtos';
+export type { RequestSummaryDto, RequestDetailDto, CollectionSummaryDto, CollectionDetailDto, CollectionItemDto, ScriptResultDto, AssertionResultDto, ExecuteRequestOutput, RequestSchemaOutput, CreateRequestOutput, UpdateRequestOutput, DeleteRequestOutput, SaveCollectionOutput, ExportCollectionOutput, LoadCollectionOutput, ListRequestsOutput, GetCollectionOutput, } from './response-dtos';

package/dist/application/dto/request-dtos.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Application DTOs — Request Input Types
+ *
+ * Standardized input objects for all use-cases.
+ * These decouple the public API from internal domain types.
+ */
+import { BodySchemaDefinition, KeyValueEntry, PathParamEntry, RequestBody, RequestScripts, RequestSettings, ResponseSchemaDefinition } from '../../types/types';
+export interface CreateRequestInput {
+    collectionId: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    /** Headers with enabled/disabled flag */
+    headers?: KeyValueEntry[];
+    /** Query parameters with enabled/disabled flag */
+    query?: KeyValueEntry[];
+    /** Path parameters */
+    params?: Record<string, string | PathParamEntry>;
+    /** Request body - supports raw, form-data, url-encoded, graphql, binary, or none */
+    body?: RequestBody;
+    /** Content-Type override */
+    bodyContentType?: string;
+    /** Request-level settings */
+    settings?: RequestSettings;
+    /** Request scripts (pre/post) */
+    scripts?: RequestScripts;
+    /** Authentication config (basic, bearer, apikey - no oauth2 at collection level) */
+    auth?: any;
+    /** Mark as disabled */
+    disabled?: boolean;
+    /** Mark as deprecated */
+    deprecated?: boolean;
+    /** Response schema */
+    responseSchema?: ResponseSchemaDefinition;
+    /** Body schema */
+    bodySchema?: BodySchemaDefinition;
+}
+export interface UpdateRequestInput {
+    collectionId: string;
+    requestId: string;
+    name?: string;
+    method?: string;
+    url?: string;
+    description?: string;
+    /** Headers with enabled/disabled flag */
+    headers?: KeyValueEntry[];
+    /** Query parameters with enabled/disabled flag */
+    query?: KeyValueEntry[];
+    /** Path parameters */
+    params?: Record<string, string | PathParamEntry>;
+    /** Request body - supports raw, form-data, url-encoded, graphql, binary, or none */
+    body?: RequestBody;
+    /** Content-Type override */
+    bodyContentType?: string;
+    /** Request-level settings */
+    settings?: RequestSettings;
+    /** Request scripts (pre/post) */
+    scripts?: RequestScripts;
+    /** Authentication config (basic, bearer, apikey - no oauth2 at collection level) */
+    auth?: any;
+    /** Mark as disabled */
+    disabled?: boolean;
+    /** Mark as deprecated */
+    deprecated?: boolean;
+    /** Response schema */
+    responseSchema?: ResponseSchemaDefinition;
+    /** Body schema */
+    bodySchema?: BodySchemaDefinition;
+}
+export interface DeleteRequestInput {
+    collectionId: string;
+    requestId: string;
+}
+export interface ListRequestsInput {
+    collectionId: string;
+}
+export interface GetCollectionInput {
+    collectionId: string;
+}
+export interface ExecuteRequestInput {
+    collectionId: string;
+    requestId: string;
+    overrides?: {
+        variables?: Record<string, any>;
+        environment?: Record<string, any>;
+    };
+}
+export interface LoadCollectionInput {
+    filePath: string;
+}
+export interface SaveCollectionInput {
+    filePath: string;
+    collectionId: string;
+}
+export type ExportFormat = 'postman' | 'openapi';
+export interface ExportCollectionInput {
+    collectionId: string;
+    format: ExportFormat;
+    outputPath: string;
+}
+export interface GetRequestSchemaInput {
+    collectionId: string;
+    requestId: string;
+}

package/dist/application/dto/response-dtos.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Application DTOs — Response Output Types
+ *
+ * Standardized output objects for all use-cases.
+ * These shield consumers from internal domain model changes.
+ */
+import { BodySchemaDefinition, KeyValueEntry, RequestBody, RequestScripts, RequestSettings, ResponseSchemaDefinition } from '../../types/types';
+export interface RequestSummaryDto {
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    disabled?: boolean;
+    deprecated?: boolean;
+}
+export interface RequestDetailDto {
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    /** Headers with per-header enabled/disabled flag */
+    headers: KeyValueEntry[];
+    /** Query parameters with per-item enabled/disabled flag */
+    query: KeyValueEntry[];
+    body?: RequestBody;
+    bodyContentType?: string;
+    auth?: any;
+    settings?: RequestSettings;
+    scripts?: RequestScripts;
+    disabled?: boolean;
+    deprecated?: boolean;
+    responseSchema?: ResponseSchemaDefinition;
+    bodySchema?: BodySchemaDefinition;
+    hasPreScript: boolean;
+    hasPostScript: boolean;
+}
+export interface CollectionSummaryDto {
+    id: string;
+    name: string;
+    description?: string;
+    requestCount: number;
+    folderCount: number;
+}
+export interface CollectionItemDto {
+    id: string;
+    name: string;
+    type: 'request' | 'folder';
+    method?: string;
+    url?: string;
+    childCount?: number;
+}
+export interface CollectionDetailDto {
+    id: string;
+    name: string;
+    description?: string;
+    items: CollectionItemDto[];
+    requestCount: number;
+    folderCount: number;
+    meta?: Record<string, any>;
+}
+/**
+ * Full Collection Detail with all nested request/folder metadata
+ * Used by LoadCollectionUseCase to return COMPLETE data (not filtered)
+ */
+export interface CollectionFullDetailDto {
+    id: string;
+    name: string;
+    description?: string;
+    /** Full nested structure with all request/folder metadata preserved */
+    items: (CollectionFullItemDto)[];
+    variables?: Record<string, string>;
+    auth?: any;
+    scripts?: RequestScripts;
+    meta?: Record<string, any>;
+}
+/**
+ * Full collection item (request or folder) with ALL metadata
+ */
+export type CollectionFullItemDto = CollectionFullRequestDto | CollectionFullFolderDto;
+/**
+ * Full request DTO with all fields preserved (headers, query, body, scripts, etc.)
+ */
+export interface CollectionFullRequestDto {
+    type: 'request';
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    headers: KeyValueEntry[];
+    query: KeyValueEntry[];
+    body?: RequestBody;
+    bodyContentType?: string;
+    auth?: any;
+    settings?: RequestSettings;
+    scripts?: RequestScripts;
+    disabled?: boolean;
+    deprecated?: boolean;
+    responseSchema?: ResponseSchemaDefinition;
+    bodySchema?: BodySchemaDefinition;
+}
+/**
+ * Full folder DTO with nested items preserved
+ */
+export interface CollectionFullFolderDto {
+    type: 'folder';
+    id: string;
+    name: string;
+    description?: string;
+    auth?: any;
+    scripts?: RequestScripts;
+    items: (CollectionFullItemDto)[];
+}
+export interface ScriptResultDto {
+    success: boolean;
+    output?: any;
+    errors: string[];
+}
+export interface AssertionResultDto {
+    name: string;
+    passed: boolean;
+    expected?: any;
+    actual?: any;
+    message?: string;
+}
+export interface ExecuteRequestOutput {
+    requestId: string;
+    status: 'success' | 'failed' | 'partial';
+    duration: number;
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string | string[]>;
+        bodySize?: number;
+    };
+    preScriptResult?: ScriptResultDto;
+    postScriptResult?: ScriptResultDto & {
+        assertions?: AssertionResultDto[];
+    };
+    variableChanges?: Record<string, any>;
+    error?: string;
+}
+export interface RequestSchemaOutput {
+    requestId: string;
+    schema: any;
+    sources: ('user' | 'history' | 'script')[];
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface CreateRequestOutput {
+    request: RequestDetailDto;
+}
+export interface UpdateRequestOutput {
+    request: RequestDetailDto;
+}
+export interface DeleteRequestOutput {
+    requestId: string;
+    collectionId: string;
+    deletedAt: string;
+}
+export interface SaveCollectionOutput {
+    filePath: string;
+    collectionName: string;
+    savedAt: string;
+}
+export interface ExportCollectionOutput {
+    collectionId: string;
+    format: string;
+    outputPath: string;
+    exportedAt: string;
+}
+export interface LoadCollectionOutput {
+    /** Full collection with ALL nested metadata preserved */
+    collection: CollectionFullDetailDto;
+    loadedFrom: string;
+}
+export interface ListRequestsOutput {
+    collectionId: string;
+    requests: RequestSummaryDto[];
+    total: number;
+}
+export interface GetCollectionOutput {
+    collection: CollectionDetailDto;
+}

package/dist/application/events/application-events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Application Events
+ *
+ * Higher-level events published by use-cases to notify the outer system
+ * (e.g. VS Code extension, CLI) about completed operations.
+ *
+ * These are distinct from domain events:
+ * - Domain events: model business invariants (RequestExecutedEvent, VariableUpdatedEvent)
+ * - Application events: notify about user actions (RequestCreatedEvent, CollectionExportedEvent)
+ */
+import { DomainEvent } from '../../domain/services/domain-events';
+export declare class RequestCreatedEvent extends DomainEvent {
+    readonly collectionId: string;
+    readonly name: string;
+    readonly method: string;
+    readonly url: string;
+    constructor(requestId: string, collectionId: string, name: string, method: string, url: string);
+}
+export declare class RequestUpdatedEvent extends DomainEvent {
+    readonly collectionId: string;
+    readonly changes: string[];
+    constructor(requestId: string, collectionId: string, changes: string[]);
+}
+export declare class RequestDeletedEvent extends DomainEvent {
+    readonly collectionId: string;
+    constructor(requestId: string, collectionId: string);
+}
+export declare class CollectionLoadedEvent extends DomainEvent {
+    readonly name: string;
+    readonly source: string;
+    readonly requestCount: number;
+    constructor(collectionId: string, name: string, source: string, // file path or identifier
+    requestCount: number);
+}
+export declare class CollectionSavedEvent extends DomainEvent {
+    readonly name: string;
+    readonly filePath: string;
+    constructor(collectionId: string, name: string, filePath: string);
+}
+export declare class CollectionExportedEvent extends DomainEvent {
+    readonly format: string;
+    readonly outputPath: string;
+    constructor(collectionId: string, format: string, outputPath: string);
+}
+export declare const ApplicationEventTypes: {
+    readonly REQUEST_CREATED: "REQUEST_CREATED";
+    readonly REQUEST_UPDATED: "REQUEST_UPDATED";
+    readonly REQUEST_DELETED: "REQUEST_DELETED";
+    readonly COLLECTION_LOADED: "COLLECTION_LOADED";
+    readonly COLLECTION_SAVED: "COLLECTION_SAVED";
+    readonly COLLECTION_EXPORTED: "COLLECTION_EXPORTED";
+};
+export type ApplicationEventType = typeof ApplicationEventTypes[keyof typeof ApplicationEventTypes];

package/dist/application/events/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Application Events
+ *
+ * Events published by use-cases to notify about completed user actions.
+ */
+export { RequestCreatedEvent, RequestUpdatedEvent, RequestDeletedEvent, CollectionLoadedEvent, CollectionSavedEvent, CollectionExportedEvent, ApplicationEventTypes, type ApplicationEventType, } from './application-events';

package/dist/application/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Application Layer - Use Cases and Queries
+ *
+ * Contains:
+ * - Use Cases (commands that modify state)
+ * - Queries (read-only operations)
+ * - Data Transfer Objects (DTOs)
+ * - Application Events
+ * - Mappers (domain ↔ DTO conversion)
+ *
+ * Constraints:
+ * - Depends on Domain and Ports layers
+ * - Orchestrates between Domain and Infrastructure
+ * - Never directly depends on Infrastructure implementations
+ *
+ * Usage:
+ * - Called by controllers/handlers
+ * - Uses repositories and executors from ports
+ * - Publishes domain events
+ */
+export * from './use-cases';
+export * from './queries';
+export * from './dto';
+export * from './events';
+export * from './mappers';

package/dist/application/mappers/collection-mapper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * CollectionMapper
+ *
+ * Maps between UnifiedCollection (domain/infrastructure type) and
+ * application-layer DTOs (CollectionDetailDto, CollectionSummaryDto, CollectionFullDetailDto).
+ *
+ * Provides two mapping strategies:
+ * - toDetail() / toSummary() - Filtered summaries for list/UI views
+ * - toFullDetail() - Complete metadata for full collection operations (load, edit)
+ */
+import { UnifiedCollection } from '../../types/types';
+import { CollectionDetailDto, CollectionFullDetailDto, CollectionSummaryDto } from '../dto/response-dtos';
+export declare class CollectionMapper {
+    /**
+     * Map domain collection to a summary DTO
+     */
+    static toSummary(collection: UnifiedCollection): CollectionSummaryDto;
+    /**
+     * Map domain collection to a full detail DTO
+     */
+    static toDetail(collection: UnifiedCollection): CollectionDetailDto;
+    /**
+     * Map domain collection to a full detail DTO (preserves ALL metadata)
+     * Used by LoadCollectionUseCase to return complete collection with all fields
+     */
+    static toFullDetail(collection: UnifiedCollection): CollectionFullDetailDto;
+    /**
+     * Map top-level items to full detail items (preserves ALL metadata per request/folder)
+     */
+    private static toFullItems;
+    /**
+     * Map top-level items to flat CollectionItemDto list
+     */
+    private static mapItems;
+    /**
+     * Recursively count requests and folders
+     */
+    private static countItems;
+}

package/dist/application/mappers/execution-result-mapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ExecutionResultMapper
+ *
+ * Maps between IExecutionResult (domain model) and
+ * ExecuteRequestOutput (application DTO).
+ */
+import { IExecutionResult } from '../../domain/models/execution';
+import { ExecuteRequestOutput } from '../dto/response-dtos';
+export declare class ExecutionResultMapper {
+    /**
+     * Map domain execution result to application-layer output DTO
+     */
+    static toOutput(result: IExecutionResult): ExecuteRequestOutput;
+    private static mapScriptResult;
+    private static mapAssertion;
+}

package/dist/application/mappers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Application Mappers
+ *
+ * Convert between domain types and application DTOs.
+ * Mappers formalize the boundary between layers.
+ */
+export { RequestMapper } from './request-mapper';
+export { CollectionMapper } from './collection-mapper';
+export { ExecutionResultMapper } from './execution-result-mapper';

package/dist/application/mappers/request-mapper.d.ts

@@ -0,0 +1,29 @@
+/**
+ * RequestMapper
+ *
+ * Maps between UnifiedRequest (domain/infrastructure type) and
+ * application-layer DTOs (RequestDetailDto, RequestSummaryDto).
+ *
+ * Preserves all metadata including enabled/disabled flags and schemas.
+ */
+import { UnifiedRequest } from '../../types/types';
+import { RequestDetailDto, RequestSummaryDto } from '../dto/response-dtos';
+export declare class RequestMapper {
+    /**
+     * Map domain request to a lightweight summary DTO
+     */
+    static toSummary(request: UnifiedRequest): RequestSummaryDto;
+    /**
+     * Map domain request to a full detail DTO
+     * PRESERVES all metadata including enabled/disabled headers and schemas
+     */
+    static toDetail(request: UnifiedRequest): RequestDetailDto;
+    /**
+     * Map multiple requests to summaries
+     */
+    static toSummaryList(requests: UnifiedRequest[]): RequestSummaryDto[];
+    /**
+     * Map multiple requests to details
+     */
+    static toDetailList(requests: UnifiedRequest[]): RequestDetailDto[];
+}

package/dist/application/queries/get-request-schema.query.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Get Request Schema Query
+ *
+ * Retrieves inferred response schema for a request
+ * Merges information from: user definition, history, script hints
+ */
+import { IRequestRepository } from '../../ports/repositories/request-repository.interface';
+import { IHistoryLoader } from '../../ports/storage/history-loader.interface';
+import { ResponseSchema } from '../../domain/services/schema-inference.domain-service';
+import { ILogger } from '../../ports/external/logger.interface';
+/**
+ * Query: Get request response schema
+ */
+export declare class GetRequestSchemaQuery {
+    private requestRepository;
+    private historyLoader;
+    private logger;
+    private schemaInference;
+    constructor(requestRepository: IRequestRepository, historyLoader: IHistoryLoader, logger: ILogger);
+    /**
+     * Get combined response schema for a request
+     */
+    execute(collectionId: string, requestId: string): Promise<ResponseSchema>;
+    /**
+     * Infer schema from historical responses
+     */
+    private inferFromHistory;
+    /**
+     * Extract property hints from post-response script
+     */
+    private extractScriptHints;
+}

package/dist/application/queries/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Application Queries
+ *
+ * Read-only operations
+ */
+export * from './get-request-schema.query';

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

@@ -0,0 +1,23 @@
+/**
+ * Create Request Use Case
+ *
+ * Creates a new HTTP request in a collection
+ * Supports full request metadata including enabled/disabled headers, schemas, etc.
+ */
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { CreateRequestInput } from '../dto/request-dtos';
+import { CreateRequestOutput } from '../dto/response-dtos';
+export type { CreateRequestInput } from '../dto/request-dtos';
+/**
+ * Use Case: Create a new request in collection
+ */
+export declare class CreateRequestUseCase {
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: CreateRequestInput): Promise<CreateRequestOutput>;
+    private generateId;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Delete Request Use Case
+ */
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { DeleteRequestInput } from '../dto/request-dtos';
+import { DeleteRequestOutput } from '../dto/response-dtos';
+export declare class DeleteRequestUseCase {
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: DeleteRequestInput): Promise<DeleteRequestOutput>;
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Execute Request Use Case - Main business workflow
+ *
+ * Orchestrates:
+ * 1. Load request from repository
+ * 2. Prepare execution environment
+ * 3. Call domain services for planning
+ * 4. Execute HTTP request via infrastructure
+ * 5. Handle scripts and variable updates
+ * 6. Publish events
+ */
+import { IRequestRepository } from '../../ports/repositories/request-repository.interface';
+import { IEnvironmentRepository } from '../../ports/repositories/environment-repository.interface';
+import { IHttpExecutor } from '../../ports/executors/http-executor.interface';
+import { IScriptExecutor } from '../../ports/executors/script-executor.interface';
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ExecuteRequestInput } from '../dto/request-dtos';
+import { ExecuteRequestOutput } from '../dto/response-dtos';
+/**
+ * Options for request execution (backward compat alias)
+ */
+export type ExecuteRequestOptions = ExecuteRequestInput;
+/**
+ * Use Case: Execute a request
+ *
+ * This is the main business workflow
+ */
+export declare class ExecuteRequestUseCase {
+    private requestRepository;
+    private environmentRepository;
+    private httpExecutor;
+    private scriptExecutor;
+    private eventPublisher;
+    private logger;
+    private planner;
+    constructor(requestRepository: IRequestRepository, environmentRepository: IEnvironmentRepository, httpExecutor: IHttpExecutor, scriptExecutor: IScriptExecutor, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    /**
+     * Execute a request from a collection
+     */
+    execute(options: ExecuteRequestInput): Promise<ExecuteRequestOutput>;
+    /**
+     * Determine overall execution status
+     */
+    private determineStatus;
+}