@railtownai/railengine 0.0.1

package/dist/esm/index.js

@@ -0,0 +1,890 @@
+/**
+ * Base error class for all Railtown API errors.
+ */
+class RailtownError extends Error {
+    constructor(message, statusCode, responseBody) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "RailtownError";
+        Object.setPrototypeOf(this, RailtownError.prototype);
+    }
+}
+/**
+ * Error thrown when authentication fails (401).
+ */
+class RailtownUnauthorizedError extends RailtownError {
+    constructor(message = "Authentication failed", responseBody) {
+        super(message, 401, responseBody);
+        this.name = "RailtownUnauthorizedError";
+        Object.setPrototypeOf(this, RailtownUnauthorizedError.prototype);
+    }
+}
+/**
+ * Error thrown when a resource is not found (404).
+ */
+class RailtownNotFoundError extends RailtownError {
+    constructor(message = "Resource not found", responseBody) {
+        super(message, 404, responseBody);
+        this.name = "RailtownNotFoundError";
+        Object.setPrototypeOf(this, RailtownNotFoundError.prototype);
+    }
+}
+/**
+ * Error thrown when a bad request is made (400).
+ */
+class RailtownBadRequestError extends RailtownError {
+    constructor(message = "Bad request", responseBody) {
+        super(message, 400, responseBody);
+        this.name = "RailtownBadRequestError";
+        Object.setPrototypeOf(this, RailtownBadRequestError.prototype);
+    }
+}
+/**
+ * Error thrown when a conflict occurs (409).
+ */
+class RailtownConflictError extends RailtownError {
+    constructor(message = "Conflict", responseBody) {
+        super(message, 409, responseBody);
+        this.name = "RailtownConflictError";
+        Object.setPrototypeOf(this, RailtownConflictError.prototype);
+    }
+}
+/**
+ * Error thrown when a server error occurs (500+).
+ */
+class RailtownServerError extends RailtownError {
+    constructor(message = "Server error", statusCode = 500, responseBody) {
+        super(message, statusCode, responseBody);
+        this.name = "RailtownServerError";
+        Object.setPrototypeOf(this, RailtownServerError.prototype);
+    }
+}
+/**
+ * Maps HTTP status codes to appropriate Railtown error classes.
+ */
+function createRailtownError(statusCode, message, responseBody) {
+    switch (statusCode) {
+        case 401:
+            return new RailtownUnauthorizedError(message, responseBody);
+        case 404:
+            return new RailtownNotFoundError(message, responseBody);
+        case 400:
+            return new RailtownBadRequestError(message, responseBody);
+        case 409:
+            return new RailtownConflictError(message, responseBody);
+        default:
+            if (statusCode >= 500) {
+                return new RailtownServerError(message, statusCode, responseBody);
+            }
+            return new RailtownError(message || `HTTP ${statusCode}`, statusCode, responseBody);
+    }
+}
+/**
+ * Strips the /api suffix from a URL if present.
+ *
+ * @param url - The URL to process
+ * @returns URL without /api suffix
+ */
+function stripApiSuffix(url) {
+    return url.replace(/\/api\/?$/, "");
+}
+
+/**
+ * Makes an HTTP request with timeout support.
+ *
+ * @param url - Request URL
+ * @param options - Request options
+ * @returns Response object
+ * @throws {Error} If request fails or times out
+ */
+async function makeHttpRequest(url, options = {}) {
+    const { timeout = 30000, signal, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const timeoutId = timeout > 0 ? setTimeout(() => controller.abort(), timeout) : null;
+    try {
+        const response = await fetch(url, {
+            ...fetchOptions,
+            signal: signal || controller.signal
+        });
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        return response;
+    }
+    catch (error) {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        throw error;
+    }
+}
+/**
+ * Handles HTTP response errors by creating appropriate RailtownError.
+ *
+ * @param response - HTTP response object
+ * @param defaultMessage - Default error message
+ * @returns Never (always throws)
+ * @throws {RailtownError} Appropriate error based on status code
+ */
+async function handleHttpError(response, defaultMessage) {
+    const responseBody = await getResponseBody(response);
+    throw createRailtownError(response.status, defaultMessage, responseBody);
+}
+/**
+ * Safely extracts response body as text, returning empty string on error.
+ *
+ * @param response - HTTP response object
+ * @returns Response body as string (empty string if extraction fails)
+ */
+async function getResponseBody(response) {
+    return await response.text().catch(() => "");
+}
+/**
+ * Handles request errors (timeout, network, etc.) with consistent error messages.
+ *
+ * @param error - Caught error
+ * @param timeout - Request timeout in milliseconds
+ * @param context - Context description for error message
+ * @returns Never (always throws)
+ * @throws {RailtownError} If error is a RailtownError
+ * @throws {Error} For timeout or other errors
+ */
+function handleRequestError(error, timeout, context) {
+    if (error instanceof RailtownError) {
+        throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeout}ms`);
+    }
+    throw new Error(`${context}: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+/**
+ * Validates and normalizes RailEngine configuration.
+ *
+ * @param pat - PAT token from options or environment variable
+ * @param engineId - Engine ID from options or environment variable
+ * @param apiUrl - Base API URL from options or environment variable
+ * @returns Validated and normalized configuration
+ * @throws {RailtownBadRequestError} If PAT or engineId is missing
+ */
+function validateRailEngineConfig(pat, engineId, apiUrl) {
+    // Get PAT from parameter or environment variable
+    const resolvedPat = pat ?? process.env.ENGINE_PAT;
+    if (!resolvedPat || typeof resolvedPat !== "string" || resolvedPat.trim().length === 0) {
+        throw new RailtownBadRequestError("PAT is required. Provide it via constructor parameter (pat) or ENGINE_PAT environment variable.");
+    }
+    // Get engineId from parameter or environment variable
+    const resolvedEngineId = engineId ?? process.env.ENGINE_ID;
+    if (!resolvedEngineId || typeof resolvedEngineId !== "string" || resolvedEngineId.trim().length === 0) {
+        throw new RailtownBadRequestError("Engine ID is required. Provide it via constructor parameter (engineId) or ENGINE_ID environment variable.");
+    }
+    // Get apiUrl from parameter or environment variable, default to production
+    const resolvedApiUrl = apiUrl ?? process.env.RAILTOWN_API_URL ?? "https://cndr.railtown.ai/api";
+    const trimmedApiUrl = resolvedApiUrl.trim();
+    // Normalize URL (strip /api suffix if present, it will be added back when constructing endpoints)
+    const normalizedApiUrl = stripApiSuffix(trimmedApiUrl);
+    return {
+        pat: resolvedPat,
+        engineId: resolvedEngineId,
+        apiUrl: trimmedApiUrl, // Original URL for display
+        normalizedApiUrl // Normalized URL for internal use
+    };
+}
+
+/**
+ * Search a vector store using semantic similarity.
+ *
+ * @param client - RailEngine client instance
+ * @param engineId - Engine identifier
+ * @param vectorStore - Vector store name (e.g., "VectorStore1", "VectorStore2", "VectorStore3")
+ * @param query - Search query string
+ * @param options - Optional filter function and schema override
+ * @returns Async iterable of search results (validated against schema if provided)
+ */
+async function* searchVectorStore(client, engineId, vectorStore, query, options) {
+    try {
+        // Determine which schema to use (override or default)
+        const schema = options?.schema ?? client._getSchema();
+        // Make POST request to search endpoint
+        const response = await client._makeRequest("POST", `/Engine/${engineId}/Embeddings/Search`, {
+            body: {
+                VectorStore: vectorStore,
+                Query: query
+            }
+        });
+        // Parse response
+        const data = await response.json().catch(() => null);
+        if (!data) {
+            return;
+        }
+        // Handle array of results
+        const dataRecord = data;
+        const results = Array.isArray(data)
+            ? data
+            : (Array.isArray(dataRecord.results)
+                ? dataRecord.results
+                : Array.isArray(dataRecord.items)
+                    ? dataRecord.items
+                    : []);
+        // Process each result
+        for (const item of results) {
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            let validatedItem = item;
+            // Validate against schema if provided
+            if (schema) {
+                try {
+                    validatedItem = schema.parse(item);
+                }
+                catch {
+                    // Skip invalid items
+                    continue;
+                }
+            }
+            // Apply filter if provided
+            if (options?.filterFn && !options.filterFn(validatedItem)) {
+                continue;
+            }
+            yield validatedItem;
+        }
+    }
+    catch {
+        // Return empty iterable on error (graceful degradation)
+        return;
+    }
+}
+
+/**
+ * Collects all items from an async iterable into an array.
+ *
+ * @param iterable - Async iterable to collect
+ * @returns Promise that resolves to an array of all items
+ */
+/**
+ * Extracts and deserializes the Body field from a storage document.
+ * The Body field is a JSON string that contains the actual document data.
+ *
+ * @param document - Storage document with Body field
+ * @param schema - Optional Zod schema to validate the deserialized body
+ * @returns Deserialized body object or null if extraction/validation fails
+ */
+function extractAndDeserializeBody(document, schema) {
+    // Extract Body or content field (JSON string)
+    // API may return either "Body" or "content" field
+    const bodyString = (document.Body || document.content);
+    if (!bodyString || typeof bodyString !== "string") {
+        return null;
+    }
+    // Parse JSON string
+    let bodyObject;
+    try {
+        bodyObject = JSON.parse(bodyString);
+    }
+    catch {
+        return null;
+    }
+    // Validate against schema if provided
+    if (schema) {
+        try {
+            return schema.parse(bodyObject);
+        }
+        catch {
+            return null;
+        }
+    }
+    return bodyObject;
+}
+/**
+ * Get a storage document by EventId.
+ *
+ * @param client - RailEngine client instance
+ * @param engineId - Engine identifier
+ * @param eventId - Event identifier
+ * @param options - Optional filter function and schema override
+ * @returns Document or null if not found or filtered out
+ */
+async function getStorageDocumentByEventId(client, engineId, eventId, options) {
+    try {
+        // Make GET request
+        const response = await client._makeRequest("GET", `/api/Engine/${engineId}/Storage`, {
+            queryParams: {
+                EventId: eventId
+            }
+        });
+        // Parse response
+        const data = await response.json().catch(() => null);
+        if (!data) {
+            return null;
+        }
+        // Handle single document or array
+        const document = Array.isArray(data) ? data[0] : data;
+        if (!document || typeof document !== "object") {
+            return null;
+        }
+        // If raw mode, return full wrapper object
+        if (options?.raw) {
+            const schema = options?.schema ?? client._getSchema();
+            let validatedDocument = document;
+            // Validate against schema if provided
+            if (schema) {
+                try {
+                    validatedDocument = schema.parse(document);
+                }
+                catch {
+                    return null;
+                }
+            }
+            // Apply filter if provided
+            if (options?.filterFn && !options.filterFn(validatedDocument)) {
+                return null;
+            }
+            return validatedDocument;
+        }
+        // Default behavior: Extract and deserialize Body field
+        const schema = options?.schema ?? client._getSchema();
+        const deserializedBody = extractAndDeserializeBody(document, schema);
+        if (deserializedBody === null) {
+            return null;
+        }
+        // Apply filter if provided
+        if (options?.filterFn && !options.filterFn(deserializedBody)) {
+            return null;
+        }
+        return deserializedBody;
+    }
+    catch {
+        // Return null on error (graceful degradation)
+        return null;
+    }
+}
+/**
+ * Get storage documents by CustomerKey.
+ *
+ * @param client - RailEngine client instance
+ * @param engineId - Engine identifier
+ * @param customerKey - Customer key
+ * @param options - Optional pagination, filter function, and schema override
+ * @returns Async iterable of documents (paginated results automatically flattened and filtered)
+ */
+async function* getStorageDocumentByCustomerKey(client, engineId, customerKey, options) {
+    const pageNumber = options?.pageNumber ?? 1;
+    const pageSize = Math.min(options?.pageSize ?? 25, 100); // Max 100
+    const schema = options?.schema ?? client._getSchema();
+    let currentPage = pageNumber;
+    let hasMorePages = true;
+    while (hasMorePages) {
+        try {
+            // Make GET request for current page
+            const response = await client._makeRequest("GET", `/api/Engine/${engineId}/Storage`, {
+                queryParams: {
+                    CustomerKey: customerKey,
+                    PageNumber: currentPage.toString(),
+                    PageSize: pageSize.toString()
+                }
+            });
+            // Parse response
+            const data = await response.json().catch(() => null);
+            if (!data) {
+                break;
+            }
+            // Handle array of documents or paginated response
+            const dataRecord = data;
+            const documents = Array.isArray(data)
+                ? data
+                : (Array.isArray(dataRecord.results)
+                    ? dataRecord.results
+                    : Array.isArray(dataRecord.items)
+                        ? dataRecord.items
+                        : []);
+            const totalPages = (typeof dataRecord.totalPages === "number" ? dataRecord.totalPages : undefined) ||
+                (typeof dataRecord.pageCount === "number" ? dataRecord.pageCount : undefined) ||
+                1;
+            // Process each document
+            for (const item of documents) {
+                if (!item || typeof item !== "object") {
+                    continue;
+                }
+                // If raw mode, yield full wrapper object
+                if (options?.raw) {
+                    // In raw mode, skip schema validation since the wrapper structure differs from Body content
+                    // The schema is meant for deserialized Body, not for the raw wrapper object
+                    let validatedItem = item;
+                    // Apply filter if provided
+                    if (options?.filterFn && !options.filterFn(validatedItem)) {
+                        continue;
+                    }
+                    yield validatedItem;
+                }
+                else {
+                    // Default behavior: Extract and deserialize Body field
+                    const deserializedBody = extractAndDeserializeBody(item, schema);
+                    if (deserializedBody === null) {
+                        continue;
+                    }
+                    // Apply filter if provided
+                    if (options?.filterFn && !options.filterFn(deserializedBody)) {
+                        continue;
+                    }
+                    yield deserializedBody;
+                }
+            }
+            // Check if there are more pages
+            hasMorePages = currentPage < totalPages && documents.length === pageSize;
+            currentPage++;
+        }
+        catch {
+            // Stop pagination on error
+            break;
+        }
+    }
+}
+/**
+ * Query storage documents using JSONPath.
+ *
+ * @param client - RailEngine client instance
+ * @param engineId - Engine identifier
+ * @param jsonPathQuery - JSONPath query string (e.g., "$.direct_report_id:1")
+ * @param options - Optional filter function and schema override
+ * @returns Async iterable of matching documents
+ */
+async function* queryStorageByJsonPath(client, engineId, jsonPathQuery, options) {
+    try {
+        const schema = options?.schema ?? client._getSchema();
+        // Make GET request
+        const response = await client._makeRequest("GET", `/api/Engine/${engineId}/Storage`, {
+            queryParams: {
+                JsonPathQuery: jsonPathQuery
+            }
+        });
+        // Parse response
+        const data = await response.json().catch(() => null);
+        if (!data) {
+            return;
+        }
+        // Handle array of documents or paginated response
+        const dataRecord = data;
+        const documents = Array.isArray(data)
+            ? data
+            : (Array.isArray(dataRecord.results)
+                ? dataRecord.results
+                : Array.isArray(dataRecord.items)
+                    ? dataRecord.items
+                    : []);
+        // Process each document
+        for (const item of documents) {
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            // If raw mode, yield full wrapper object
+            if (options?.raw) {
+                // In raw mode, skip schema validation since the wrapper structure differs from Body content
+                // The schema is meant for deserialized Body, not for the raw wrapper object
+                let validatedItem = item;
+                // Apply filter if provided
+                if (options?.filterFn && !options.filterFn(validatedItem)) {
+                    continue;
+                }
+                yield validatedItem;
+            }
+            else {
+                // Default behavior: Extract and deserialize Body field
+                const deserializedBody = extractAndDeserializeBody(item, schema);
+                if (deserializedBody === null) {
+                    continue;
+                }
+                // Apply filter if provided
+                if (options?.filterFn && !options.filterFn(deserializedBody)) {
+                    continue;
+                }
+                yield deserializedBody;
+            }
+        }
+    }
+    catch {
+        // Return empty iterable on error (graceful degradation)
+        return;
+    }
+}
+/**
+ * List storage documents.
+ *
+ * @param client - RailEngine client instance
+ * @param engineId - Engine identifier
+ * @param options - Optional pagination, customer key filter, filter function, and schema override
+ * @returns Async iterable of documents (paginated results automatically flattened and filtered)
+ */
+async function* listStorageDocuments(client, engineId, options) {
+    const pageNumber = options?.pageNumber ?? 1;
+    const pageSize = Math.min(options?.pageSize ?? 100, 100); // Max 100
+    const schema = options?.schema ?? client._getSchema();
+    let currentPage = pageNumber;
+    let hasMorePages = true;
+    while (hasMorePages) {
+        try {
+            // Build query parameters
+            const queryParams = {
+                PageNumber: currentPage.toString(),
+                PageSize: pageSize.toString()
+            };
+            if (options?.customerKey) {
+                queryParams.CustomerKey = options.customerKey;
+            }
+            // Make GET request for current page
+            const response = await client._makeRequest("GET", `/api/Engine/${engineId}/Storage`, {
+                queryParams
+            });
+            // Parse response
+            const data = await response.json().catch(() => null);
+            if (!data) {
+                break;
+            }
+            // Handle array of documents or paginated response
+            const dataRecord = data;
+            const documents = Array.isArray(data)
+                ? data
+                : (Array.isArray(dataRecord.results)
+                    ? dataRecord.results
+                    : Array.isArray(dataRecord.items)
+                        ? dataRecord.items
+                        : []);
+            const totalPages = (typeof dataRecord.totalPages === "number" ? dataRecord.totalPages : undefined) ||
+                (typeof dataRecord.pageCount === "number" ? dataRecord.pageCount : undefined) ||
+                1;
+            // Process each document
+            for (const item of documents) {
+                if (!item || typeof item !== "object") {
+                    continue;
+                }
+                // If raw mode, yield full wrapper object
+                if (options?.raw) {
+                    // In raw mode, skip schema validation since the wrapper structure differs from Body content
+                    // The schema is meant for deserialized Body, not for the raw wrapper object
+                    let validatedItem = item;
+                    // Apply filter if provided
+                    if (options?.filterFn && !options.filterFn(validatedItem)) {
+                        continue;
+                    }
+                    yield validatedItem;
+                }
+                else {
+                    // Default behavior: Extract and deserialize Body field
+                    const deserializedBody = extractAndDeserializeBody(item, schema);
+                    if (deserializedBody === null) {
+                        continue;
+                    }
+                    // Apply filter if provided
+                    if (options?.filterFn && !options.filterFn(deserializedBody)) {
+                        continue;
+                    }
+                    yield deserializedBody;
+                }
+            }
+            // Check if there are more pages
+            hasMorePages = currentPage < totalPages && documents.length === pageSize;
+            currentPage++;
+        }
+        catch {
+            // Stop pagination on error
+            break;
+        }
+    }
+}
+
+/**
+ * Search index using Azure Search.
+ *
+ * @param client - RailEngine client instance
+ * @param projectId - Project identifier
+ * @param engineId - Engine identifier
+ * @param query - Search query object (e.g., { search: "query" })
+ * @param options - Optional filter function and schema override
+ * @returns Async iterable of search results (validated against schema if provided)
+ */
+async function* searchIndex(client, projectId, engineId, query, options) {
+    try {
+        // Determine which schema to use (override or default)
+        const schema = options?.schema ?? client._getSchema();
+        // Make POST request to search endpoint
+        const response = await client._makeRequest("POST", `/Engine/Indexing/Search`, {
+            body: {
+                ProjectId: projectId,
+                EngineId: engineId,
+                ...query
+            }
+        });
+        // Parse response
+        const data = await response.json().catch(() => null);
+        if (!data) {
+            return;
+        }
+        // Handle array of results or paginated response
+        const dataRecord = data;
+        const results = Array.isArray(data)
+            ? data
+            : (Array.isArray(dataRecord.results)
+                ? dataRecord.results
+                : Array.isArray(dataRecord.items)
+                    ? dataRecord.items
+                    : Array.isArray(dataRecord.value)
+                        ? dataRecord.value
+                        : []);
+        // Process each result
+        for (const item of results) {
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            let validatedItem = item;
+            // Validate against schema if provided
+            if (schema) {
+                try {
+                    validatedItem = schema.parse(item);
+                }
+                catch {
+                    // Skip invalid items
+                    continue;
+                }
+            }
+            // Apply filter if provided
+            if (options?.filterFn && !options.filterFn(validatedItem)) {
+                continue;
+            }
+            yield validatedItem;
+        }
+    }
+    catch {
+        // Return empty iterable on error (graceful degradation)
+        return;
+    }
+}
+
+/**
+ * Client for retrieving and searching data from Rail Engine.
+ */
+class RailEngine {
+    /**
+     * Initialize the Rail Engine retrieval client.
+     *
+     * @param options - Configuration options
+     * @throws {RailtownBadRequestError} If PAT or engineId is missing
+     */
+    constructor(options = {}) {
+        const config = validateRailEngineConfig(options.pat, options.engineId, options.apiUrl);
+        this.pat = config.pat;
+        this.engineId = config.engineId;
+        this.apiUrl = config.apiUrl; // Original URL for display
+        this.normalizedApiUrl = config.normalizedApiUrl; // Normalized URL for internal use
+        this.schema = options.schema;
+        this.timeout = options.timeout ?? 30000;
+    }
+    /**
+     * Makes an authenticated HTTP request.
+     *
+     * @param method - HTTP method
+     * @param path - API path (will be appended to base URL)
+     * @param options - Request options
+     * @returns Response object
+     * @throws {RailtownError} If the request fails
+     */
+    async _request(method, path, options = {}) {
+        // Construct URL using normalized base URL
+        const url = new URL(`${this.normalizedApiUrl}${path}`);
+        if (options.queryParams) {
+            for (const [key, value] of Object.entries(options.queryParams)) {
+                url.searchParams.append(key, value);
+            }
+        }
+        // Prepare request body
+        let body;
+        if (options.body !== undefined) {
+            body = JSON.stringify(options.body);
+        }
+        // Make request
+        try {
+            const response = await makeHttpRequest(url.toString(), {
+                method,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: this.pat
+                },
+                body,
+                timeout: this.timeout
+            });
+            // Handle errors (but don't throw - let calling methods handle gracefully)
+            if (!response.ok) {
+                await handleHttpError(response, `Request failed: ${response.statusText}`);
+            }
+            return response;
+        }
+        catch (error) {
+            return handleRequestError(error, this.timeout, "Request failed");
+        }
+    }
+    /**
+     * Search a vector store using semantic similarity.
+     *
+     * @param engineId - Engine identifier
+     * @param vectorStore - Vector store name (e.g., "VectorStore1")
+     * @param query - Search query string
+     * @param options - Optional filter function and schema override
+     * @returns Async iterable of search results
+     */
+    searchVectorStore(engineId, vectorStore, query, options) {
+        return searchVectorStore(this, engineId, vectorStore, query, options);
+    }
+    /**
+     * Get a storage document by EventId.
+     *
+     * @param params - Parameters object
+     * @param params.eventId - Event identifier
+     * @param params.engineId - Optional engine identifier (defaults to client.engineId)
+     * @param params.filterFn - Optional filter function
+     * @param params.schema - Optional schema override
+     * @param params.raw - If true, returns full wrapper object with metadata instead of deserialized Body
+     * @returns Document or null if not found. When a schema is provided (via constructor or options), returns T | null.
+     *          When no schema is provided, returns Record<string, unknown> | null.
+     */
+    async getStorageDocumentByEventId(params) {
+        const engineId = params.engineId ?? this.engineId;
+        return getStorageDocumentByEventId(this, engineId, params.eventId, {
+            filterFn: params.filterFn,
+            schema: params.schema,
+            raw: params.raw
+        });
+    }
+    /**
+     * Get storage documents by CustomerKey.
+     *
+     * @param params - Parameters object
+     * @param params.customerKey - Customer key
+     * @param params.engineId - Optional engine identifier (defaults to client.engineId)
+     * @param params.pageNumber - Optional page number (defaults to 1)
+     * @param params.pageSize - Optional page size (defaults to 25, max 100)
+     * @param params.filterFn - Optional filter function
+     * @param params.schema - Optional schema override
+     * @param params.raw - If true, returns full wrapper object with metadata instead of deserialized Body
+     * @returns Promise that resolves to an array of documents. Pagination is handled automatically.
+     *          When a schema is provided (via constructor or options), returns Promise<T[]>.
+     */
+    async getStorageDocumentByCustomerKey(params) {
+        const engineId = params.engineId ?? this.engineId;
+        const iterable = getStorageDocumentByCustomerKey(this, engineId, params.customerKey, {
+            pageNumber: params.pageNumber,
+            pageSize: params.pageSize,
+            filterFn: params.filterFn,
+            schema: params.schema,
+            raw: params.raw
+        });
+        const results = [];
+        for await (const item of iterable) {
+            results.push(item);
+        }
+        return results;
+    }
+    /**
+     * Query storage documents using JSONPath.
+     *
+     * @param params - Parameters object
+     * @param params.jsonPathQuery - JSONPath query string (e.g., "$.direct_report_id:1")
+     * @param params.engineId - Optional engine identifier (defaults to client.engineId)
+     * @param params.filterFn - Optional filter function
+     * @param params.schema - Optional schema override
+     * @param params.raw - If true, returns full wrapper object with metadata instead of deserialized Body
+     * @returns Promise that resolves to an array of matching documents.
+     *          When a schema is provided (via constructor or options), returns Promise<T[]>.
+     */
+    async queryStorageByJsonPath(params) {
+        const engineId = params.engineId ?? this.engineId;
+        const iterable = queryStorageByJsonPath(this, engineId, params.jsonPathQuery, {
+            filterFn: params.filterFn,
+            schema: params.schema,
+            raw: params.raw
+        });
+        const results = [];
+        for await (const item of iterable) {
+            results.push(item);
+        }
+        return results;
+    }
+    /**
+     * List storage documents.
+     *
+     * @param params - Parameters object
+     * @param params.engineId - Optional engine identifier (defaults to client.engineId)
+     * @param params.customerKey - Optional customer key filter
+     * @param params.pageNumber - Optional page number (defaults to 1)
+     * @param params.pageSize - Optional page size (defaults to 100, max 100)
+     * @param params.filterFn - Optional filter function
+     * @param params.schema - Optional schema override
+     * @param params.raw - If true, returns full wrapper object with metadata instead of deserialized Body
+     * @returns Promise that resolves to an array of documents. Pagination is handled automatically.
+     *          When a schema is provided (via constructor or options), returns Promise<T[]>.
+     */
+    async listStorageDocuments(params) {
+        const engineId = params?.engineId ?? this.engineId;
+        const iterable = listStorageDocuments(this, engineId, {
+            customerKey: params?.customerKey,
+            pageNumber: params?.pageNumber,
+            pageSize: params?.pageSize,
+            filterFn: params?.filterFn,
+            schema: params?.schema,
+            raw: params?.raw
+        });
+        const results = [];
+        for await (const item of iterable) {
+            results.push(item);
+        }
+        return results;
+    }
+    /**
+     * Search index using Azure Search.
+     *
+     * @param projectId - Project identifier
+     * @param engineId - Engine identifier
+     * @param query - Search query object (e.g., { search: "query" })
+     * @param options - Optional filter function and schema override
+     * @returns Async iterable of search results
+     */
+    searchIndex(projectId, engineId, query, options) {
+        return searchIndex(this, projectId, engineId, query, options);
+    }
+    /**
+     * Delete an event from the engine.
+     *
+     * @param params - Parameters object
+     * @param params.eventId - Event identifier to delete
+     * @param params.engineId - Optional engine identifier (defaults to client.engineId)
+     * @returns Promise that resolves when deletion is successful or accepted
+     * @throws {RailtownNotFoundError} If engine is not found (404)
+     * @throws {RailtownServerError} If service is unavailable (503)
+     * @throws {RailtownUnauthorizedError} If authentication fails (401)
+     *
+     * The operation is idempotent - calling deleteEvent multiple times with the same eventId
+     * will succeed. The API returns:
+     * - 204: Event deleted immediately or already deleted
+     * - 202: Deletion accepted, may take time (eventually consistent)
+     */
+    async deleteEvent(params) {
+        const engineId = params.engineId ?? this.engineId;
+        await this._makeRequest("DELETE", `/api/Engine/${engineId}/Event/${params.eventId}`);
+    }
+    /**
+     * Internal method to make authenticated requests (used by API modules).
+     *
+     * @internal
+     */
+    async _makeRequest(method, path, options = {}) {
+        return this._request(method, path, options);
+    }
+    /**
+     * Get the default schema for this client.
+     *
+     * @internal
+     */
+    _getSchema() {
+        return this.schema;
+    }
+}
+
+export { RailEngine };
+//# sourceMappingURL=index.js.map