@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.4

package/index-C3-iD9Mh.d.ts

@@ -0,0 +1,690 @@
+import { f as TypeInfoMap, h as TypeInfo, C as ComparisonOperators, F as FieldCriterion, S as SearchCriteria, T as TypeInfoDataItem, i as SortField, d as TypeKeyword, j as ItemRelationshipInfoType, k as ItemRelationshipInfoKeys, H as HelperTypes, l as ItemRelationshipInfoTypes, m as SearchTypes } from './SearchTypes-DjN6YQzE.js';
+import { V as Validation, T as TypeInfoValidationResults } from './Validation-CFP59oIP.js';
+import { TypeAliasDeclaration, Node } from 'typescript';
+
+/**
+ * Extracts type information from TypeScript content.
+ *
+ * @param source - TypeScript source text to parse.
+ * @returns Map of exported type info definitions.
+ */
+declare const getTypeInfoMapFromTypeScript: (source: string) => TypeInfoMap;
+
+/**
+ * AST mapping helpers for extracting type aliases from TypeScript sources.
+ */
+
+/**
+ * A map of type aliases in the TypeScript AST.
+ */
+type TypeMap = Record<string, TypeAliasDeclaration>;
+/**
+ * Converts a TypeScript AST to a map of type aliases.
+ *
+ * @param node - AST node to traverse.
+ * @param map - Accumulator map of type aliases.
+ * @param parentName - Parent module name for nested namespaces.
+ * @returns Map of type alias declarations keyed by name.
+ */
+declare const convertASTToMap: (node: Node, map?: Record<string, TypeAliasDeclaration>, parentName?: string) => TypeMap;
+
+type TypeMapping_TypeMap = TypeMap;
+declare const TypeMapping_convertASTToMap: typeof convertASTToMap;
+declare namespace TypeMapping {
+  export { type TypeMapping_TypeMap as TypeMap, TypeMapping_convertASTToMap as convertASTToMap };
+}
+
+/**
+ * Built-in type names used when parsing TypeInfo.
+ * */
+declare const BUILTIN_TYPE_NAMES: string[];
+
+declare const Constants_BUILTIN_TYPE_NAMES: typeof BUILTIN_TYPE_NAMES;
+declare namespace Constants {
+  export { Constants_BUILTIN_TYPE_NAMES as BUILTIN_TYPE_NAMES };
+}
+
+/**
+ * @packageDocumentation
+ *
+ * Type parsing utilities for deriving TypeInfo from TypeScript source.
+ * Includes TypeInfo definitions, validation helpers, and AST mapping.
+ */
+
+declare const index$5_Constants: typeof Constants;
+declare const index$5_TypeInfo: typeof TypeInfo;
+declare const index$5_TypeMapping: typeof TypeMapping;
+declare const index$5_Validation: typeof Validation;
+declare const index$5_getTypeInfoMapFromTypeScript: typeof getTypeInfoMapFromTypeScript;
+declare namespace index$5 {
+  export { index$5_Constants as Constants, index$5_TypeInfo as TypeInfo, index$5_TypeMapping as TypeMapping, index$5_Validation as Validation, index$5_getTypeInfoMapFromTypeScript as getTypeInfoMapFromTypeScript };
+}
+
+/**
+ * Helpers for parsing and composing path strings used by the Router utilities.
+ */
+/**
+ * The delimiter used to separate paths.
+ */
+declare const PATH_DELIMITER = "/";
+/**
+ * Parse a string into JSON if possible, otherwise return the raw value.
+ *
+ * @param value - Input string to parse.
+ * @returns Parsed JSON or the original string.
+ */
+declare const getPotentialJSONValue: (value: string) => any;
+/**
+ * Get the path segments from a path string.
+ *
+ * @param path - Path string to split.
+ * @param delimiter - Delimiter used to split the path.
+ * @param filterEmptyOutput - Whether to remove empty output segments.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to parse each segment as JSON.
+ * @param uriDecodeParts - Whether to URI-decode each segment.
+ * @returns Array of path segments.
+ * */
+declare const getPathArray: (path: string, delimiter?: string, filterEmptyOutput?: boolean, filterEmptyInput?: boolean, useJson?: boolean, uriDecodeParts?: boolean) => any[];
+/**
+ * Get the path string from path segments.
+ *
+ * @param parts - Path segments to join.
+ * @param delimiter - Delimiter used to join the path.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to JSON-stringify each segment.
+ * @param uriEncodeParts - Whether to URI-encode each segment.
+ * @returns Joined path string.
+ * */
+declare const getPathString: (parts?: any[], delimiter?: string, filterEmptyInput?: boolean, useJson?: boolean, uriEncodeParts?: boolean) => string;
+/**
+ * Merge two path strings.
+ *
+ * @param path1 - First path string.
+ * @param path2 - Second path string.
+ * @param delimiter - Delimiter used to split and join paths.
+ * @param filterEmptyOutput - Whether to remove empty output segments.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to parse/serialize segments as JSON.
+ * @param uriEncodeParts - Whether to URI-encode each segment.
+ * @returns Merged path string.
+ * */
+declare const mergeStringPaths: (path1: string, path2: string, delimiter?: string, filterEmptyOutput?: boolean, filterEmptyInput?: boolean, useJson?: boolean, uriEncodeParts?: boolean) => string;
+/**
+ * Resolve a path string against another path string.
+ *
+ * @param currentPath - Base path to resolve against.
+ * @param newPath - New path to resolve, absolute or relative.
+ * @returns Resolved path string.
+ * */
+declare const resolvePath: (currentPath: string, newPath: string) => string;
+/**
+ * Get the parameter values from a path string and test the `path` against a `testPath`.
+ *
+ * @param path - Actual path to test.
+ * @param testPath - Route pattern to match against.
+ * @param exact - Whether to require an exact match.
+ * @returns Params object when matched, otherwise false.
+ * */
+declare const getParamsAndTestPath: (path: string, testPath: string, exact?: boolean) => Record<string, any> | false;
+
+declare const Routing_PATH_DELIMITER: typeof PATH_DELIMITER;
+declare const Routing_getParamsAndTestPath: typeof getParamsAndTestPath;
+declare const Routing_getPathArray: typeof getPathArray;
+declare const Routing_getPathString: typeof getPathString;
+declare const Routing_getPotentialJSONValue: typeof getPotentialJSONValue;
+declare const Routing_mergeStringPaths: typeof mergeStringPaths;
+declare const Routing_resolvePath: typeof resolvePath;
+declare namespace Routing {
+  export { Routing_PATH_DELIMITER as PATH_DELIMITER, Routing_getParamsAndTestPath as getParamsAndTestPath, Routing_getPathArray as getPathArray, Routing_getPathString as getPathString, Routing_getPotentialJSONValue as getPotentialJSONValue, Routing_mergeStringPaths as mergeStringPaths, Routing_resolvePath as resolvePath };
+}
+
+/**
+ * Get a simple id, unique to the current run session.
+ *
+ * Includes a counter and timestamp so it stays unique within the same process.
+ *
+ * @returns A process-unique string id.
+ */
+declare const getSimpleId: () => string;
+
+declare const index$4_getSimpleId: typeof getSimpleId;
+declare namespace index$4 {
+  export { index$4_getSimpleId as getSimpleId };
+}
+
+/**
+ * Filtering and sorting utilities for search criteria.
+ */
+
+/**
+ * Basic comparison operators for filtering data.
+ * */
+declare const COMPARATORS: Record<ComparisonOperators, (
+/**
+ * Criterion value to compare against.
+ * */
+criterionValue: any, 
+/**
+ * Criterion options for operators like IN/BETWEEN.
+ * */
+criterionValueOptions: any[] | undefined, 
+/**
+ * Field value from the item.
+ * */
+fieldValue: any) => boolean>;
+/**
+ * Compare a field criterion to a field value.
+ *
+ * @param fieldCriterion - Criterion to compare.
+ * @param fieldValue - Field value to test.
+ * @returns Whether the criterion matches the field value.
+ * */
+declare const compare$1: (fieldCriterion: FieldCriterion, fieldValue: any) => boolean;
+/**
+ * Compare a field criterion to an array of field values.
+ *
+ * @param fieldCriterion - Criterion to compare.
+ * @param fieldValue - Array field value to test.
+ * @returns Whether the criterion matches the field value array.
+ * */
+declare const compareArray: (fieldCriterion: FieldCriterion, fieldValue: any[] | undefined) => boolean;
+/**
+ * Get the filtered data items based on the search criteria.
+ *
+ * @param searchCriteria - Criteria to apply.
+ * @param items - Items to filter.
+ * @param typeInfoName - Optional type name for field metadata.
+ * @param typeInfoMap - Optional type info map for field metadata.
+ * @returns Filtered items that match the criteria.
+ * */
+declare const getFilterTypeInfoDataItemsBySearchCriteria: (searchCriteria: SearchCriteria, items: TypeInfoDataItem[], typeInfoName?: string, typeInfoMap?: TypeInfoMap) => TypeInfoDataItem[];
+/**
+ * Get the sorted data items based on the given sort fields.
+ *
+ * @param sortFields - Sort field configuration.
+ * @param items - Items to sort.
+ * @returns Sorted items array.
+ * */
+declare const getSortedItems: (sortFields?: SortField[], items?: TypeInfoDataItem[]) => TypeInfoDataItem[];
+
+declare const SearchUtils_COMPARATORS: typeof COMPARATORS;
+declare const SearchUtils_compareArray: typeof compareArray;
+declare const SearchUtils_getFilterTypeInfoDataItemsBySearchCriteria: typeof getFilterTypeInfoDataItemsBySearchCriteria;
+declare const SearchUtils_getSortedItems: typeof getSortedItems;
+declare namespace SearchUtils {
+  export { SearchUtils_COMPARATORS as COMPARATORS, compare$1 as compare, SearchUtils_compareArray as compareArray, SearchUtils_getFilterTypeInfoDataItemsBySearchCriteria as getFilterTypeInfoDataItemsBySearchCriteria, SearchUtils_getSortedItems as getSortedItems };
+}
+
+/**
+ * Built-in and custom string transformers for type keywords.
+ */
+
+/**
+ * A function that transforms a value into a string.
+ *
+ * @param value - Value to transform.
+ * @returns String representation of the value.
+ * */
+type StringTransformer = (value: any) => string;
+/**
+ * A map of string transformers for each type keyword.
+ * */
+declare const STRING_TRANSFORMERS: Record<TypeKeyword, StringTransformer>;
+/**
+ * A map of custom string transformers for each custom type.
+ * */
+declare const CUSTOM_STRING_TRANSFORMERS: Record<string, StringTransformer>;
+/**
+ * Transform a value into a string based on the type keyword or custom type.
+ *
+ * @param value - Value to transform.
+ * @param typeKeyword - Type keyword used to select the transformer.
+ * @param customType - Custom type name, if applicable.
+ * @returns String representation for the value.
+ * */
+declare const transformValueToString: (value: any, typeKeyword: TypeKeyword, customType?: string) => string;
+
+declare const StringTransformers_CUSTOM_STRING_TRANSFORMERS: typeof CUSTOM_STRING_TRANSFORMERS;
+declare const StringTransformers_STRING_TRANSFORMERS: typeof STRING_TRANSFORMERS;
+type StringTransformers_StringTransformer = StringTransformer;
+declare const StringTransformers_transformValueToString: typeof transformValueToString;
+declare namespace StringTransformers {
+  export { StringTransformers_CUSTOM_STRING_TRANSFORMERS as CUSTOM_STRING_TRANSFORMERS, StringTransformers_STRING_TRANSFORMERS as STRING_TRANSFORMERS, type StringTransformers_StringTransformer as StringTransformer, StringTransformers_transformValueToString as transformValueToString };
+}
+
+/**
+ * Validation helpers for relationship items.
+ */
+
+/**
+ * Error codes for relationship validation.
+ * */
+declare const TYPE_INFO_ORM_RELATIONSHIP_ERRORS: {
+    INVALID_RELATIONSHIP_ITEM: string;
+    INVALID_RELATIONSHIP_ITEM_FIELD: string;
+};
+/**
+ * Validates a relationship item.
+ *
+ * @param relationshipItem - Relationship item to validate.
+ * @param omitFields - Relationship keys to ignore during validation.
+ * @returns Validation results with errors and errorMap when invalid.
+ * */
+declare const validateRelationshipItem: (relationshipItem: ItemRelationshipInfoType, omitFields?: ItemRelationshipInfoKeys[]) => TypeInfoValidationResults;
+
+declare const index$3_TYPE_INFO_ORM_RELATIONSHIP_ERRORS: typeof TYPE_INFO_ORM_RELATIONSHIP_ERRORS;
+declare const index$3_validateRelationshipItem: typeof validateRelationshipItem;
+declare namespace index$3 {
+  export { index$3_TYPE_INFO_ORM_RELATIONSHIP_ERRORS as TYPE_INFO_ORM_RELATIONSHIP_ERRORS, index$3_validateRelationshipItem as validateRelationshipItem };
+}
+
+/**
+ * Operations used for comparison during tests.
+ */
+declare enum TestComparisonOperation {
+    /**
+     * Strict equality comparison.
+     * */
+    EQUALS = "===",
+    /**
+     * Strict inequality comparison.
+     * */
+    NOT_EQUALS = "!==",
+    /**
+     * Value is contained in expectation array.
+     * */
+    IN = "IN",
+    /**
+     * Array contains the expectation value.
+     * */
+    ARRAY_CONTAINS = "ARRAY_CONTAINS",
+    /**
+     * Numeric value is between two bounds.
+     * */
+    BETWEEN = "BETWEEN",
+    /**
+     * String contains another string.
+     * */
+    CONTAINS = "CONTAINS",
+    /**
+     * Regex match against a pattern.
+     * */
+    REGEX = "REGEX",
+    /**
+     * Extended regex match with explicit pattern elements.
+     * */
+    EXT_REGEX = "EXT_REGEX",
+    /**
+     * Deep equality using JSON stringification.
+     * */
+    DEEP_EQUALS = "DEEP_EQUALS",
+    /**
+     * Array equality using JSON stringification.
+     * */
+    ARRAY_EQUALS = "ARRAY_EQUALS"
+}
+/**
+ * A pattern definition object for use with extended regex expectations.
+ * */
+type PatternElement = {
+    /**
+     * Literal pattern segment value.
+     * */
+    value: string;
+    /**
+     * Whether to escape regex characters in the value.
+     * */
+    escaped?: boolean;
+};
+/**
+ * An extended regex expectation with a patter structure, optional flags and
+ * escaping properties that allow for clear and explicit declaration of regex
+ * patterns in JSON.
+ *
+ * Used when a `TestCondition` `operation` is `TestComparisonOperation.EXT_REGEX`.
+ * */
+type EXTRegexExpectation = {
+    /**
+     * Pattern elements to build the regex.
+     * */
+    pattern: PatternElement[];
+    /**
+     * Regex flags to apply.
+     * */
+    flags?: string;
+};
+/**
+ * A regex expectation with a pattern and optional flags.
+ *
+ * Used when a `TestCondition` `operation` is `TestComparisonOperation.REGEX`.
+ * */
+type RegexExpectation = {
+    /**
+     * Regex pattern string.
+     * */
+    pattern: string;
+    /**
+     * Regex flags to apply.
+     * */
+    flags?: string;
+};
+/**
+ * A configuration used to acquire conditions from code instead of a JSON array.
+ * */
+type ConditionConfig = {
+    /**
+     * Relative file path containing the conditions export.
+     * */
+    file: string;
+    /**
+     * Export name that contains the conditions array.
+     * */
+    export: string;
+};
+/**
+ * Preparation for a test when some setup is required or a class needs to be instantiated.
+ * */
+type TestSetup = {
+    /**
+     * Conditions to use for the setup function or constructor.
+     * */
+    conditions: unknown[] | ConditionConfig;
+    /**
+     * Export name to call or instantiate for setup.
+     * */
+    export: string;
+    /**
+     * Whether to use `new` with the setup export.
+     * */
+    instantiate?: boolean;
+};
+/**
+ * The basis for a test.
+ * */
+type BaseTest = {
+    /**
+     * Export name for the test function.
+     * */
+    export: string;
+    /**
+     * Optional setup configuration.
+     * */
+    setup?: TestSetup;
+    /**
+     * Conditions to pass to the test function.
+     * */
+    conditions: unknown[] | ConditionConfig;
+    /**
+     * Allow missing expectation and treat undefined as pass.
+     * */
+    expectUndefined?: boolean;
+};
+/**
+ * A singular test with specific types of expectations for a given operation.
+ * */
+type Test = BaseTest & ({
+    operation?: TestComparisonOperation.EQUALS | TestComparisonOperation.NOT_EQUALS;
+    expectation: string | number | boolean | null | undefined;
+} | {
+    operation: TestComparisonOperation.IN | TestComparisonOperation.ARRAY_CONTAINS;
+    expectation: unknown[];
+} | {
+    operation: TestComparisonOperation.BETWEEN;
+    expectation: [number, number];
+} | {
+    operation: TestComparisonOperation.CONTAINS;
+    expectation: string;
+} | {
+    operation: TestComparisonOperation.REGEX;
+    expectation: RegexExpectation;
+} | {
+    operation: TestComparisonOperation.EXT_REGEX;
+    expectation: EXTRegexExpectation;
+} | {
+    operation: TestComparisonOperation.DEEP_EQUALS;
+    expectation: Record<string, unknown>;
+} | {
+    operation: TestComparisonOperation.ARRAY_EQUALS;
+    expectation: unknown[];
+});
+/**
+ * A configuration for a test. Designed to be used in JSON spec files.
+ */
+type TestConfig = {
+    /**
+     * Relative module path containing test exports.
+     * */
+    file: string;
+    /**
+     * Tests to execute for the module.
+     * */
+    tests: Test[];
+};
+/**
+ * A resolved test configuration with the module and tests.
+ * */
+type ResolvedTestConfig = {
+    /**
+     * Required module with test exports.
+     * */
+    targetModule: any;
+} & TestConfig;
+/**
+ * The results from running one or more tests.
+ * */
+type TestResults = {
+    /**
+     * Informational messages.
+     * */
+    messages?: string[];
+    /**
+     * Generated expectation messages.
+     * */
+    generated?: string[];
+    /**
+     * Passed test messages.
+     * */
+    passes?: string[];
+    /**
+     * Failed test messages.
+     * */
+    failures?: string[];
+    /**
+     * Error messages.
+     * */
+    errors?: string[];
+};
+
+/**
+ * @packageDocumentation
+ *
+ * Helpers for executing JSON spec tests, including expectation generation.
+ */
+
+/**
+ * A map of comparison functions for each `TestComparisonOperation`.
+ * */
+declare const OPERATIONS: Record<string, (a: unknown, b: unknown) => boolean>;
+/**
+ * Compare a result with an expectation using a specified `TestComparisonOperation`.
+ *
+ * @param result - Actual test result.
+ * @param expectation - Expected value.
+ * @param operation - Comparison operation to use.
+ * @returns Whether the result matches the expectation.
+ * */
+declare const compare: (result: unknown, expectation: unknown, operation?: TestComparisonOperation) => boolean;
+/**
+ * Get the target module for testing from a file being tested.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param targetTestIndex - Index of the test in the test array.
+ * @param targetTestExport - Export name for the test.
+ * @param conditions - Conditions array or config to load.
+ * @param isSetup - Whether the conditions are for setup.
+ * @returns Resolved conditions array.
+ * */
+declare const getResolvedConditions: (testFilePath: string, targetTestIndex: number, targetTestExport: string, conditions: unknown[] | ConditionConfig, isSetup?: boolean) => Promise<unknown[]>;
+/**
+ * Get the target base instance from a module, for a given test setup.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param targetTestIndex - Index of the test in the test array.
+ * @param targetTestExport - Export name for the test.
+ * @param test - Test definition.
+ * @param module - Required module containing exports.
+ * @returns Instance to use for the test function.
+ * */
+declare const getSetupInstance: (testFilePath: string, targetTestIndex: number, targetTestExport: string, test: Test, module: any) => Promise<any>;
+/**
+ * Resolve the test function from the target module or setup instance.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param file - Module file defined in the test config.
+ * @param targetTestIndex - Index of the test in the test array.
+ * @param test - Test definition.
+ * @param targetModule - Required module containing exports.
+ * @returns Test function to execute.
+ */
+declare const getTestFunction: (testFilePath: string, file: string, targetTestIndex: number, test: Test, targetModule: any) => Promise<(...args: unknown[]) => Promise<unknown> | unknown>;
+/**
+ * Get the test configuration from a test file.
+ *
+ * @param testFilePath - Path to the test file.
+ * @returns Parsed test config.
+ * */
+declare const getTestConfig: (testFilePath: string) => Promise<TestConfig>;
+/**
+ * Get the target module for testing from a file being tested.
+ *
+ * @param testFilePath - Path to the test file.
+ * @returns Resolved test config with module and tests.
+ * */
+declare const getResolvedTestConfig: (testFilePath: string) => Promise<ResolvedTestConfig>;
+/**
+ * Merge multiple test results into a single result.
+ *
+ * @param results - Test result sets to merge.
+ * @returns Combined test results.
+ * */
+declare const mergeTestResults: (...results: TestResults[]) => TestResults;
+/**
+ * Run a test using a test function and a test condition.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param testFunction - Test function to execute.
+ * @param test - Test definition.
+ * @param index - Test index in the list.
+ * @param targetExport - Export name for the test.
+ * @param report - Reporter for test results.
+ * @returns Resolves when the test completes.
+ * */
+declare const runTest: (testFilePath: string, testFunction: (...args: unknown[]) => Promise<unknown> | unknown, test: Test, index: number, targetExport: string, report: (results: TestResults) => void) => Promise<void>;
+/**
+ * Generate tests for a file by running the tests, capturing the current result and storing it as the new expectation.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param report - Reporter for test results.
+ * @returns Resolves when generation completes.
+ * */
+declare const generateTestsForFile: (testFilePath: string, report: (results: TestResults) => void) => Promise<void>;
+/**
+ * Run the tests for a given test file.
+ *
+ * The test file content is expected to be a JSON in the structure of a `TestConfig`.
+ *
+ * @param testFilePath - Path to the test file.
+ * @param report - Reporter for test results.
+ * @returns Resolves when tests finish.
+ * */
+declare const runTestsForFile: (testFilePath: string, report: (results: TestResults) => void) => Promise<void>;
+/**
+ * Run or generate all of the tests in the specified `testPath` glob.
+ *
+ * @param testFiles - Test file paths to execute.
+ * @param generateMode - Whether to generate expectations.
+ * @param report - Reporter for test results.
+ * @returns Resolves when execution completes.
+ * */
+declare const executeTestingCommand: (testFiles: string[], generateMode: boolean | undefined, report: (results: TestResults) => void) => Promise<void>;
+
+/**
+ * @packageDocumentation
+ *
+ * JSON-spec testing helpers used by the custom test runner. Specs live alongside
+ * code in `*.spec.json` files and point to test-utils modules.
+ */
+
+type index$2_BaseTest = BaseTest;
+type index$2_ConditionConfig = ConditionConfig;
+type index$2_EXTRegexExpectation = EXTRegexExpectation;
+declare const index$2_OPERATIONS: typeof OPERATIONS;
+type index$2_PatternElement = PatternElement;
+type index$2_RegexExpectation = RegexExpectation;
+type index$2_ResolvedTestConfig = ResolvedTestConfig;
+type index$2_Test = Test;
+type index$2_TestComparisonOperation = TestComparisonOperation;
+declare const index$2_TestComparisonOperation: typeof TestComparisonOperation;
+type index$2_TestConfig = TestConfig;
+type index$2_TestResults = TestResults;
+type index$2_TestSetup = TestSetup;
+declare const index$2_compare: typeof compare;
+declare const index$2_executeTestingCommand: typeof executeTestingCommand;
+declare const index$2_generateTestsForFile: typeof generateTestsForFile;
+declare const index$2_getResolvedConditions: typeof getResolvedConditions;
+declare const index$2_getResolvedTestConfig: typeof getResolvedTestConfig;
+declare const index$2_getSetupInstance: typeof getSetupInstance;
+declare const index$2_getTestConfig: typeof getTestConfig;
+declare const index$2_getTestFunction: typeof getTestFunction;
+declare const index$2_mergeTestResults: typeof mergeTestResults;
+declare const index$2_runTest: typeof runTest;
+declare const index$2_runTestsForFile: typeof runTestsForFile;
+declare namespace index$2 {
+  export { type index$2_BaseTest as BaseTest, type index$2_ConditionConfig as ConditionConfig, type index$2_EXTRegexExpectation as EXTRegexExpectation, index$2_OPERATIONS as OPERATIONS, type index$2_PatternElement as PatternElement, type index$2_RegexExpectation as RegexExpectation, type index$2_ResolvedTestConfig as ResolvedTestConfig, type index$2_Test as Test, index$2_TestComparisonOperation as TestComparisonOperation, type index$2_TestConfig as TestConfig, type index$2_TestResults as TestResults, type index$2_TestSetup as TestSetup, index$2_compare as compare, index$2_executeTestingCommand as executeTestingCommand, index$2_generateTestsForFile as generateTestsForFile, index$2_getResolvedConditions as getResolvedConditions, index$2_getResolvedTestConfig as getResolvedTestConfig, index$2_getSetupInstance as getSetupInstance, index$2_getTestConfig as getTestConfig, index$2_getTestFunction as getTestFunction, index$2_mergeTestResults as mergeTestResults, index$2_runTest as runTest, index$2_runTestsForFile as runTestsForFile };
+}
+
+/**
+ * Logging tags used by {@link logFunctionCall}.
+ */
+declare enum LOGGING_MESSAGES {
+    LOGGING_FUNCTION_CALL = "LOGGING_FUNCTION_CALL",
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT",
+    ERROR = "ERROR"
+}
+/**
+ * Make a function call and log input/output/errors when enabled.
+ *
+ * @param label - Label to include in logs.
+ * @param args - Arguments passed to the function.
+ * @param functionRef - Function to execute.
+ * @param enabled - Whether to emit logs.
+ * @returns The function result.
+ */
+declare const logFunctionCall: (label: string, args: any[], functionRef: (...args: any[]) => Promise<any> | any, enabled: boolean) => Promise<any>;
+
+type index$1_LOGGING_MESSAGES = LOGGING_MESSAGES;
+declare const index$1_LOGGING_MESSAGES: typeof LOGGING_MESSAGES;
+declare const index$1_logFunctionCall: typeof logFunctionCall;
+declare namespace index$1 {
+  export { index$1_LOGGING_MESSAGES as LOGGING_MESSAGES, index$1_logFunctionCall as logFunctionCall };
+}
+
+/**
+ * @packageDocumentation
+ *
+ * Common module exports for shared utilities, types, and helpers.
+ */
+
+declare const index_HelperTypes: typeof HelperTypes;
+declare const index_ItemRelationshipInfoTypes: typeof ItemRelationshipInfoTypes;
+declare const index_Routing: typeof Routing;
+declare const index_SearchTypes: typeof SearchTypes;
+declare const index_SearchUtils: typeof SearchUtils;
+declare const index_StringTransformers: typeof StringTransformers;
+declare namespace index {
+  export { index_HelperTypes as HelperTypes, index$4 as IDGeneration, index_ItemRelationshipInfoTypes as ItemRelationshipInfoTypes, index$3 as ItemRelationships, index$1 as Logging, index_Routing as Routing, index_SearchTypes as SearchTypes, index_SearchUtils as SearchUtils, index_StringTransformers as StringTransformers, index$2 as Testing, index$5 as TypeParsing };
+}
+
+export { Routing as R, SearchUtils as S, index$5 as a, index$4 as b, StringTransformers as c, index$3 as d, index$2 as e, index$1 as f, index as i };