@http-forge/core 0.1.0 → 0.2.0

package/dist/graphql/graphql-completion-provider.d.ts

@@ -0,0 +1,39 @@
+/**
+ * GraphQL Completion Provider
+ *
+ * Single Responsibility: Parse GraphQL document context and produce completion items
+ * from a given schema. Pure logic — no VS Code or editor dependencies.
+ *
+ * This is a lightweight context parser using regex + brace counting — no graphql-js dependency.
+ *
+ * Completion Scenarios:
+ * - Root level: query, mutation, subscription, fragment keywords
+ * - Selection set: fields of the current parent type + __typename
+ * - Arguments: field argument names
+ * - Argument values: enum values for enum-typed arguments
+ * - Fragment spread: on TypeName, defined fragment names
+ * - Directives: @skip, @include, custom directives
+ * - Variable types: input types + scalars
+ */
+import { GraphQLSchema } from './graphql-schema-service';
+export type ContextType = 'root' | 'operation_name' | 'selection_set' | 'argument' | 'argument_value' | 'directive' | 'fragment_type' | 'variable_def';
+export interface QueryContext {
+    contextType: ContextType;
+    fieldPath: string[];
+    parentType?: string;
+    inFragment?: boolean;
+    prefix: string;
+    currentField?: string;
+    currentArg?: string;
+}
+export interface CompletionItem {
+    label: string;
+    kind: 'field' | 'keyword' | 'argument' | 'enum' | 'type' | 'directive' | 'fragment' | 'snippet';
+    detail?: string;
+    description?: string;
+    insertText?: string;
+    deprecated?: boolean;
+    sortOrder?: number;
+}
+export declare function parseQueryContext(document: string, offset: number, schema?: GraphQLSchema): QueryContext;
+export declare function getCompletions(schema: GraphQLSchema, context: QueryContext): CompletionItem[];

package/dist/graphql/graphql-schema-service.d.ts

@@ -0,0 +1,89 @@
+/**
+ * GraphQL Schema Service
+ *
+ * Single Responsibility: Fetch, parse, and cache GraphQL schemas via introspection.
+ *
+ * Features:
+ * - Execute standard introspection query against any GraphQL endpoint
+ * - Parse introspection result into typed schema representation
+ * - Cache schemas per-endpoint with timestamp
+ * - Extract operation names from GraphQL documents
+ * - Resolve variable types for operations
+ *
+ * Zero Dependencies: Uses only the project's IHttpClient abstraction.
+ */
+import { IHttpClient } from '../types/platform';
+export interface GraphQLField {
+    name: string;
+    type: string;
+    args: GraphQLArg[];
+    description?: string;
+    isDeprecated: boolean;
+    deprecationReason?: string;
+}
+export interface GraphQLArg {
+    name: string;
+    type: string;
+    defaultValue?: string;
+    description?: string;
+}
+export interface GraphQLEnumValue {
+    name: string;
+    description?: string;
+    isDeprecated: boolean;
+    deprecationReason?: string;
+}
+export interface GraphQLType {
+    name: string;
+    kind: 'OBJECT' | 'INPUT_OBJECT' | 'ENUM' | 'SCALAR' | 'INTERFACE' | 'UNION' | 'LIST' | 'NON_NULL';
+    fields: GraphQLField[];
+    inputFields: GraphQLArg[];
+    enumValues: GraphQLEnumValue[];
+    interfaces: string[];
+    possibleTypes: string[];
+    description?: string;
+}
+export interface GraphQLDirective {
+    name: string;
+    description?: string;
+    locations: string[];
+    args: GraphQLArg[];
+}
+export interface GraphQLSchema {
+    queryType: string;
+    mutationType?: string;
+    subscriptionType?: string;
+    types: Map<string, GraphQLType>;
+    directives: GraphQLDirective[];
+    fetchedAt: number;
+    endpointUrl: string;
+}
+export interface GraphQLOperation {
+    name: string;
+    type: 'query' | 'mutation' | 'subscription';
+    line: number;
+}
+export interface IGraphQLSchemaService {
+    fetchSchema(endpointUrl: string, headers?: Record<string, string>): Promise<GraphQLSchema>;
+    getCachedSchema(endpointUrl: string): GraphQLSchema | undefined;
+    extractOperations(document: string): GraphQLOperation[];
+    clearCache(endpointUrl?: string): void;
+    schemaToSerializable(schema: GraphQLSchema): any;
+}
+export declare class GraphQLSchemaService implements IGraphQLSchemaService {
+    private readonly httpClient;
+    private schemaCache;
+    constructor(httpClient: IHttpClient);
+    /**
+     * Execute introspection query and return parsed schema
+     */
+    fetchSchema(endpointUrl: string, headers?: Record<string, string>): Promise<GraphQLSchema>;
+    getCachedSchema(endpointUrl: string): GraphQLSchema | undefined;
+    extractOperations(document: string): GraphQLOperation[];
+    clearCache(endpointUrl?: string): void;
+    schemaToSerializable(schema: GraphQLSchema): any;
+    private parseSchema;
+    private parseField;
+    private parseArg;
+    private renderTypeRef;
+}

package/dist/{interfaces/history.d.ts → 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 } from './types';
+import { HttpRequest, HttpResponse, RequestBody } from '../types/types';
 /**
  * History entry - records a single request execution
  */
@@ -14,7 +14,7 @@ export interface HistoryEntry {
     /** Timestamp of execution */
     timestamp: number;
     /** Associated ticket/issue number */
-    ticket?: string;
+    ticket?: string | null;
     /** Git branch name */
     branch?: string;
     /** Environment used */
@@ -26,10 +26,34 @@ export interface HistoryEntry {
         url: string;
         method: string;
         headers: Record<string, string>;
-        body?: any;
+        body?: RequestBody | any | null;
         params?: Record<string, string>;
         query?: Record<string, string>;
     };
+    /** Original request configuration (before variable resolution) */
+    originalConfig?: {
+        path: string;
+        params: Record<string, string>;
+        query: Record<string, string>;
+        headers: Record<string, string>;
+        body: RequestBody | null;
+    };
+    /** Request settings */
+    settings?: {
+        timeout?: number;
+        followRedirects?: boolean;
+        followOriginalMethod?: boolean;
+        followAuthHeader?: boolean;
+        maxRedirects?: number;
+        strictSSL?: boolean;
+        decompress?: boolean;
+        includeCookies?: boolean;
+    };
+    /** Scripts associated with request */
+    scripts?: {
+        preRequest?: string;
+        postResponse?: string;
+    };
     /** Response summary */
     response: {
         status: number;
@@ -46,7 +70,7 @@ export interface FullResponse {
     timestamp: number;
     status: number;
     statusText: string;
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     cookies: any[];
     body: any;
     time: number;
@@ -59,7 +83,7 @@ export interface RequestHistory {
     requestPath: string;
     requestId: string;
     method: string;
-    entries: HistoryEntry[];
+    requests: HistoryEntry[];
 }
 /**
  * History read operations
@@ -114,4 +138,3 @@ export interface IRequestHistory extends IHistoryReader, IHistoryWriter {
     /** Maximum entries to keep per request (oldest removed when exceeded) */
     maxEntriesPerRequest: number;
 }
-//# sourceMappingURL=history.d.ts.map

package/dist/history/request-history-service-interfaces.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Request History Service Interface
+ *
+ * Interface Segregation: Separated into focused sub-interfaces
+ * Dependency Inversion: Consumers depend on this abstraction
+ */
+import { FullResponse, HistoryEntry, RequestHistory } from './history-interfaces';
+export type { FullResponse, HistoryEntry, RequestHistory };
+/**
+ * History read operations
+ */
+export interface IHistoryReader {
+    loadHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    loadSharedHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    getEntriesForEnvironment(environment: string, storagePath: string, endpointId: string): HistoryEntry[];
+    getEntriesGroupedByTicket(environment: string, storagePath: string, endpointId: string): Map<string, HistoryEntry[]>;
+    getSharedEntriesGroupedByTicket(environment: string, storagePath: string, endpointId: string): Map<string, HistoryEntry[]>;
+}
+/**
+ * History write operations
+ */
+export interface IHistoryWriter {
+    addEntry(environment: string, storagePath: string, endpointId: string, method: string, entry: Omit<HistoryEntry, 'id' | 'timestamp' | 'method'>): HistoryEntry;
+    deleteEntry(environment: string, storagePath: string, endpointId: string, entryId: string): boolean;
+    deleteSharedEntry(environment: string, storagePath: string, endpointId: string, entryId: string): boolean;
+    clearHistory(environment: string, storagePath: string, endpointId: string): void;
+    shareEntry(environment: string, storagePath: string, endpointId: string, entryId: string, tag: string): boolean;
+    moveSharedEntry(environment: string, storagePath: string, endpointId: string, entryId: string, tag: string): boolean;
+    renameSharedGroup(environment: string, storagePath: string, endpointId: string, oldTag: string, newTag: string): boolean;
+}
+/**
+ * Full response storage operations
+ */
+export interface IResponseStorage {
+    saveFullResponse(environment: string, requestPath: string, requestId: string, entryId: string, response: FullResponse): void;
+    loadFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+    loadSharedFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+}
+/**
+ * Full request history service interface
+ */
+export interface IRequestHistoryService extends IHistoryReader, IHistoryWriter, IResponseStorage {
+}

package/dist/history/request-history-service.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Request History Service - File-based Implementation
+ *
+ * Full-featured request history service with:
+ * - File-based persistence (JSON files on disk)
+ * - Shared history support (team-visible history)
+ * - Ticket/branch grouping
+ * - Separate full response file management
+ *
+ * Ported from VS Code extension's RequestHistoryService.
+ * No VS Code dependencies — uses only Node.js fs/path.
+ */
+import { FullResponse, HistoryEntry, RequestHistory } from './history-interfaces';
+import { IRequestHistoryService } from './request-history-service-interfaces';
+/**
+ * File-based request history service.
+ *
+ * Path-helper methods are `protected` so consumers can subclass and
+ * override the directory layout if needed.
+ */
+export declare class RequestHistoryService implements IRequestHistoryService {
+    protected historyPath: string;
+    protected sharedHistoryPath: string;
+    constructor(historyPath: string, sharedHistoryPath: string);
+    /**
+     * Get history folder path for environment
+     */
+    protected getEnvironmentHistoryPath(environment: string): string;
+    /**
+     * Get history folder path for a collection within an environment
+     */
+    protected getCollectionHistoryPath(environment: string, collectionPath: string): string;
+    /**
+     * Get request directory path
+     */
+    protected getRequestPath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get shared history folder path for environment
+     */
+    protected getSharedEnvironmentHistoryPath(environment: string): string;
+    /**
+     * Get shared history folder path for a collection within an environment
+     */
+    protected getSharedCollectionHistoryPath(environment: string, collectionPath: string): string;
+    /**
+     * Get shared request directory path
+     */
+    protected getSharedRequestPath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get history file path for a request
+     */
+    protected getHistoryFilePath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get shared history file path for a request
+     */
+    protected getSharedHistoryFilePath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get full response file path
+     */
+    protected getResponseFilePath(environment: string, requestPath: string, requestId: string, entryId: string): string;
+    /**
+     * Get shared full response file path
+     */
+    protected getSharedResponseFilePath(environment: string, requestPath: string, requestId: string, entryId: string): string;
+    /**
+     * Load history for a request
+     */
+    loadHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    /**
+     * Load shared history for a request
+     */
+    loadSharedHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    /**
+     * Get history entries for a specific environment / request
+     */
+    getEntriesForEnvironment(environment: string, requestPath: string, requestId: string): HistoryEntry[];
+    /**
+     * Get history entries grouped by ticket/branch
+     */
+    getEntriesGroupedByTicket(environment: string, requestPath: string, requestId: string): Map<string, HistoryEntry[]>;
+    /**
+     * Get shared history entries grouped by ticket/branch
+     */
+    getSharedEntriesGroupedByTicket(environment: string, requestPath: string, requestId: string): Map<string, HistoryEntry[]>;
+    /**
+     * Save history for a request (internal)
+     */
+    protected saveHistory(history: RequestHistory): void;
+    /**
+     * Save shared history for a request (internal)
+     */
+    protected saveSharedHistory(history: RequestHistory): void;
+    /**
+     * Add a new entry to the history
+     */
+    addEntry(environment: string, requestPath: string, requestId: string, method: string, entry: Omit<HistoryEntry, 'id' | 'timestamp' | 'method'>): HistoryEntry;
+    /**
+     * Delete a specific entry
+     */
+    deleteEntry(environment: string, requestPath: string, requestId: string, entryId: string): boolean;
+    /**
+     * Delete a specific entry from shared history
+     */
+    deleteSharedEntry(environment: string, requestPath: string, requestId: string, entryId: string): boolean;
+    /**
+     * Move entry to shared history and remove from local history
+     */
+    shareEntry(environment: string, requestPath: string, requestId: string, entryId: string, tag: string): boolean;
+    /**
+     * Move a shared history entry to another group tag
+     */
+    moveSharedEntry(environment: string, requestPath: string, requestId: string, entryId: string, tag: string): boolean;
+    /**
+     * Rename a shared history group tag
+     */
+    renameSharedGroup(environment: string, requestPath: string, requestId: string, oldTag: string, newTag: string): boolean;
+    /**
+     * Clear all history for a request
+     */
+    clearHistory(environment: string, requestPath: string, requestId: string): void;
+    /**
+     * Save full response to a separate file
+     */
+    saveFullResponse(environment: string, requestPath: string, requestId: string, entryId: string, response: FullResponse): void;
+    /**
+     * Load full response from file
+     */
+    loadFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+    /**
+     * Load full response from shared history file
+     */
+    loadSharedFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+}

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

@@ -7,8 +7,8 @@
  * Based on VS Code plugin's RequestHistoryService logic,
  * but adapted for storage-agnostic design.
  */
-import { FullResponse, HistoryEntry, IRequestHistory } from '../interfaces/history';
-import { HttpRequest, HttpResponse } from '../interfaces/types';
+import { FullResponse, HistoryEntry, IRequestHistory } from './history-interfaces';
+import { HttpRequest, HttpResponse } from '../types/types';
 /**
  * In-memory request history storage
  *
@@ -70,4 +70,3 @@ export declare class RequestHistoryStore implements IRequestHistory {
      */
     clearAll(): void;
 }
-//# sourceMappingURL=request-history.d.ts.map

package/dist/{implementations → http}/fetch-http-client.d.ts

@@ -4,16 +4,15 @@
  * Single Responsibility: Execute HTTP requests using fetch API
  * Dependency Inversion: Implements IHttpClient interface
  */
-import { IHttpClient } from '../interfaces';
-import { HttpRequest, HttpResponse } from '../interfaces/types';
+import { IHttpClient } from '../types/platform';
+import { HttpRequest, HttpResponse } from '../types/types';
 /**
  * HTTP client implementation using Node.js native fetch.
  * Requires Node.js 18+.
  */
 export declare class FetchHttpClient implements IHttpClient {
     /**
-     * Execute an HTTP request
+     * Send an HTTP request
      */
-    execute(request: HttpRequest): Promise<HttpResponse>;
+    send(request: HttpRequest): Promise<HttpResponse>;
 }
-//# sourceMappingURL=fetch-http-client.d.ts.map

package/dist/http/http-request-service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HTTP Request Service
+ *
+ * High-level facade that orchestrates HTTP request execution through:
+ * - Request interceptors (pre-processing)
+ * - HTTP client (actual network call)
+ * - Response interceptors (post-processing)
+ * - Error interceptors (error recovery)
+ * - URL building (path param + query param substitution)
+ *
+ * Extracted from extension's http-request-service.ts.
+ *
+ * SOLID:
+ * - Single Responsibility: Orchestrates HTTP requests via interceptors
+ * - Open/Closed: Extended through interceptor chain
+ * - Dependency Inversion: Depends on IHttpClient, IUrlBuilder, IInterceptorChain, IRequestPreprocessor
+ */
+import { IInterceptorChain } from './interceptor-chain';
+import { HttpRequestOptions, HttpResponse } from '../types/types';
+import type { IHttpClient } from '../types/platform';
+import { IHttpRequestService } from './interfaces';
+import { IUrlBuilder } from './url-builder';
+export declare class HttpRequestService implements IHttpRequestService {
+    private readonly urlBuilder;
+    private readonly interceptors;
+    private readonly httpClient;
+    constructor(urlBuilder: IUrlBuilder, interceptors: IInterceptorChain, httpClient: IHttpClient);
+    /**
+     * Execute an HTTP request with interceptor support.
+     */
+    execute(options: HttpRequestOptions): Promise<HttpResponse>;
+    /**
+     * Build full URL from URL pattern, params, and query.
+     */
+    buildUrl(urlPattern: string, params?: Record<string, string>, query?: Record<string, string>): string;
+}

package/dist/{implementations → http}/interceptor-chain.d.ts

@@ -12,7 +12,7 @@
  * - Post-response processing (modify response after receiving)
  * - Error handling
  */
-import { HttpRequest, HttpResponse } from '../interfaces/types';
+import { HttpRequest, HttpResponse } from '../types/types';
 /**
  * Context passed to interceptors
  * Same as plugin's InterceptorContext
@@ -259,4 +259,3 @@ export declare class RetryErrorInterceptor implements IErrorInterceptor {
     constructor(maxRetries?: number, retryableErrors?: string[]);
     handle(error: Error, _request: HttpRequest, _context: InterceptorContext): void;
 }
-//# sourceMappingURL=interceptor-chain.d.ts.map

package/dist/http/interfaces.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HTTP Request Service Interface
+ *
+ * Combines HTTP execution (IHttpClient) with URL building (IUrlBuilder).
+ * Adds interceptor support for pre/post processing of requests and responses.
+ *
+ * This is the high-level service interface that consumers use.
+ * It delegates to IHttpClient for actual network calls and IUrlBuilder for URL construction.
+ */
+import { HttpRequestOptions, HttpResponse } from '../types/types';
+/**
+ * Full HTTP request service interface.
+ * Combines execution + URL building in a single facade.
+ */
+export interface IHttpRequestService {
+    /**
+     * Execute an HTTP request with interceptor support.
+     */
+    execute(options: HttpRequestOptions): Promise<HttpResponse>;
+    /**
+     * Build a full URL from path with parameter and query substitution.
+     * Path is expected to have {{variables}} pre-resolved by caller.
+     */
+    buildUrl(path: string, params?: Record<string, string>, query?: Record<string, string>): string;
+}

package/dist/http/merge-request-settings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Merge Request Settings
+ *
+ * Merges user-provided request settings with defaults.
+ * Extracted from extension's utils/merge-request-settings.ts.
+ */
+import { RequestSettings } from '../types/types';
+/**
+ * Merge user-provided RequestSettings with defaults.
+ * Idempotent and safe to call from multiple layers.
+ */
+export declare function mergeRequestSettings(userSettings?: Partial<RequestSettings>): Required<RequestSettings>;

package/dist/{implementations → http}/native-http-client.d.ts

@@ -14,34 +14,26 @@
  * - Request cancellation via AbortSignal
  * - Cookie parsing from Set-Cookie headers
  */
-import { IHttpClient } from '../interfaces';
-import { ParsedCookie } from '../interfaces/cookie';
-import { HttpRequest, HttpResponse, RequestSettings } from '../interfaces/types';
+import { IHttpClient } from '../types/platform';
+import { HttpRequest, HttpResponse, RequestSettings } from '../types/types';
 /**
  * Default request settings
  * Same as plugin's DEFAULT_REQUEST_SETTINGS from shared/constants.ts
  */
 export declare const DEFAULT_REQUEST_SETTINGS: Required<RequestSettings>;
-/**
- * Extended HTTP response with raw cookie data for internal use
- * Compatible with HttpResponse through the cookies field
- */
-export interface HttpResponseWithCookies extends HttpResponse {
-    /** Parsed cookie objects with full details */
-    rawCookies: ParsedCookie[];
-}
 /**
  * Native HTTP client using Node.js http/https modules
  *
  * Implementation extracted 100% from plugin's HttpRequestService.executeInternal
  */
-export declare class NativeHttpClient implements IHttpClient {
+export declare class NodeHttpClient implements IHttpClient {
     private settings;
+    private version;
     constructor(defaultSettings?: Partial<RequestSettings>);
     /**
-     * Execute an HTTP request
+     * Send an HTTP request
      */
-    execute(request: HttpRequest): Promise<HttpResponse>;
+    send(request: HttpRequest): Promise<HttpResponse>;
     /**
      * Merge user settings with defaults
      * Same implementation as plugin's HttpRequestService.mergeSettings
@@ -69,4 +61,3 @@ export declare class NativeHttpClient implements IHttpClient {
      */
     private parseCookies;
 }
-//# sourceMappingURL=native-http-client.d.ts.map

package/dist/{implementations → http}/request-preprocessor.d.ts

@@ -6,7 +6,7 @@
  * Single Responsibility: Handles request preparation (header sanitization, body encoding)
  * DO NOT modify the core logic - it has been tested and is reliable.
  */
-import { RequestBody } from '../interfaces/types';
+import { RequestBody } from '../types/types';
 /**
  * Request Preprocessor Interface
  * Same as plugin's IRequestPreprocessor
@@ -75,4 +75,3 @@ export declare class RequestPreprocessor implements IRequestPreprocessor {
      */
     setContentTypeHeader(headers: Record<string, string>, body: RequestBody | null | undefined, bodyContentType?: string): void;
 }
-//# sourceMappingURL=request-preprocessor.d.ts.map

package/dist/{services → http}/url-builder.d.ts

@@ -8,19 +8,18 @@
  * - Path parameter replacement: :param, :param(regex), :param?
  * - Query string building and merging
  */
-import { IVariableInterpolator } from '../interfaces';
 /**
  * URL Builder interface
  */
 export interface IUrlBuilder {
     /**
-     * Build a complete URL with variable and path parameter substitution
-     * @param urlPattern - URL pattern with {{vars}} and :params
-     * @param variables - Variables for {{var}} replacement
+     * Build a complete URL with path parameter and query string substitution.
+     * Matches extension's IUrlBuilder — expects {{variables}} pre-resolved.
+     * @param path - URL path (with {{variables}} pre-resolved by caller)
      * @param params - Path parameters for :param replacement
      * @param query - Query parameters to append
      */
-    buildUrl(urlPattern: string, variables: Record<string, string>, params?: Record<string, string>, query?: Record<string, string>): string;
+    buildUrl(path: string, params?: Record<string, string>, query?: Record<string, string>): string;
     /**
      * Replace only path parameters (:param) in a URL
      */
@@ -34,12 +33,11 @@ export interface IUrlBuilder {
  * URL Builder implementation
  */
 export declare class UrlBuilder implements IUrlBuilder {
-    private readonly interpolator;
-    constructor(interpolator: IVariableInterpolator);
     /**
-     * Build a complete URL with all substitutions
+     * Build a complete URL with all substitutions.
+     * Expects {{variables}} in urlPattern to be pre-resolved by caller.
      */
-    buildUrl(urlPattern: string, variables: Record<string, string>, params?: Record<string, string>, query?: Record<string, string>): string;
+    buildUrl(urlPattern: string, params?: Record<string, string>, query?: Record<string, string>): string;
     /**
      * Replace path parameters in URL
      * Supports:
@@ -57,4 +55,3 @@ export declare class UrlBuilder implements IUrlBuilder {
      */
     private appendQueryParams;
 }
-//# sourceMappingURL=url-builder.d.ts.map

package/dist/import-export/import-postman-environment.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Postman Environment Import
+ *
+ * Parses Postman environment JSON files into a standard format.
+ * Extracted from extension's utils/import-postman-environment.ts.
+ *
+ * Pure function — no platform dependencies.
+ */
+import { IFileSystem } from '../types/platform';
+import { ImportedEnvironment } from '../environment/interfaces';
+export type { ImportedEnvironment } from '../environment/interfaces';
+/**
+ * Parse Postman environment JSON content.
+ * Supports both standard and nested Postman export formats.
+ */
+export declare function parsePostmanEnvironment(content: string | Buffer): ImportedEnvironment | null;
+/**
+ * Parse Postman environment from file using the IFileSystem abstraction.
+ * Platform-independent — works with any IFileSystem implementation.
+ */
+export declare function parsePostmanEnvironmentFile(filePath: string, fs: IFileSystem): Promise<ImportedEnvironment | null>;