@ucdjs/ucd-store 0.0.1 → 1.0.1-beta.1

package/dist/index.d.mts

@@ -0,0 +1,747 @@
+import { OperationResult, PathFilter, PathFilterOptions } from "@ucdjs-internal/shared";
+import { UCDClient } from "@ucdjs/client";
+import { FileSystemBridge, FileSystemBridgeArgs, FileSystemBridgeFactory } from "@ucdjs/fs-bridge";
+import z from "zod";
+import { ExpectedFile, UCDWellKnownConfig, UnicodeFileTreeNode } from "@ucdjs/schemas";
+
+//#region src/errors.d.ts
+declare abstract class UCDStoreBaseError extends Error {
+  constructor(message: string);
+}
+declare class UCDStoreGenericError extends UCDStoreBaseError {
+  readonly data?: Record<string, unknown>;
+  constructor(message: string, data?: Record<string, unknown>);
+}
+declare class UCDStoreFileNotFoundError extends UCDStoreBaseError {
+  readonly filePath: string;
+  readonly version?: string;
+  constructor(filePath: string, version?: string);
+}
+declare class UCDStoreVersionNotFoundError extends UCDStoreBaseError {
+  readonly version: string;
+  constructor(version: string);
+}
+declare class UCDStoreBridgeUnsupportedOperation extends UCDStoreBaseError {
+  readonly operation: string;
+  readonly requiredCapabilities: string[];
+  readonly availableCapabilities: string[];
+  constructor(operation: string, requiredCapabilities: string[], availableCapabilities: string[]);
+}
+declare class UCDStoreInvalidManifestError extends UCDStoreBaseError {
+  readonly manifestPath: string;
+  readonly details: string[];
+  constructor({
+    manifestPath,
+    message,
+    details
+  }: {
+    manifestPath: string;
+    message: string;
+    details?: string[];
+  });
+}
+declare class UCDStoreNotInitializedError extends UCDStoreBaseError {
+  constructor();
+}
+declare class UCDStoreApiFallbackError extends UCDStoreBaseError {
+  readonly version: string;
+  readonly filePath: string;
+  readonly status?: number;
+  readonly reason: "fetch-failed" | "no-data";
+  constructor({
+    version,
+    filePath,
+    status,
+    reason,
+    message
+  }: {
+    version: string;
+    filePath: string;
+    status?: number;
+    reason: "fetch-failed" | "no-data";
+    message?: string;
+  });
+}
+type StoreError = UCDStoreGenericError | UCDStoreFileNotFoundError | UCDStoreVersionNotFoundError | UCDStoreBridgeUnsupportedOperation | UCDStoreInvalidManifestError | UCDStoreNotInitializedError | UCDStoreApiFallbackError;
+//#endregion
+//#region src/files/get.d.ts
+interface GetFileOptions extends SharedOperationOptions {
+  /**
+   * Whether to allow falling back to API if file is not found in local store
+   * @default false
+   */
+  allowApi?: boolean;
+}
+//#endregion
+//#region src/files/list.d.ts
+interface ListFilesOptions extends SharedOperationOptions {
+  /**
+   * Whether to allow falling back to API if files are not found in local store
+   * @default false
+   */
+  allowApi?: boolean;
+}
+//#endregion
+//#region src/files/tree.d.ts
+interface GetFileTreeOptions extends SharedOperationOptions {
+  /**
+   * Whether to allow falling back to API if files are not found in local store
+   * @default false
+   */
+  allowApi?: boolean;
+}
+//#endregion
+//#region src/reports/analyze.d.ts
+interface AnalyzeOptions extends SharedOperationOptions {
+  /**
+   * Specific versions to analyze. If not provided, analyzes all versions.
+   */
+  versions?: string[];
+}
+interface AnalysisFilesReport {
+  /**
+   * List of files that were found in the store for this version.
+   * NOTE: This does not include orphaned files.
+   */
+  present: ReportFile[];
+  /**
+   * List of orphaned files (in store but not expected).
+   */
+  orphaned: ReportFile[];
+  /**
+   * List of files missing from the store.
+   */
+  missing: ReportFile[];
+}
+interface AnalysisVersionReport extends BaseVersionReport {
+  /**
+   * Whether the version is complete.
+   * True if all expected files are present and no orphaned files exist.
+   */
+  isComplete: boolean;
+  /**
+   * Categorized file lists.
+   */
+  files: AnalysisFilesReport;
+  /**
+   * Breakdown of file types by extension.
+   * Provides insight into the composition of files within the version.
+   */
+  fileTypes: Record<string, number>;
+}
+interface AnalysisReport extends BaseOperationReport {
+  /**
+   * Per-version analysis results.
+   */
+  versions: Map<string, AnalysisVersionReport>;
+}
+//#endregion
+//#region src/reports/compare.d.ts
+/**
+ * Single mode types for comparison.
+ * - "prefer-local": Try local first, fall back to API if not found
+ * - "local": Only use local files, fail if not present
+ * - "api": Only use API, never check local files
+ */
+type SingleModeType = "prefer-local" | "local" | "api";
+/**
+ * Comparison mode configuration.
+ * Can be a single mode applied to both versions, or a tuple specifying different modes for from/to.
+ *
+ * @example
+ * // Single mode - same behavior for both versions
+ * mode: "prefer-local"
+ *
+ * @example
+ * // Tuple mode - different behavior for from/to
+ * mode: ["local", "api"] // from uses local, to uses API
+ */
+type ComparisonMode = SingleModeType | readonly [SingleModeType, SingleModeType];
+interface CompareOptions extends SharedOperationOptions {
+  /** Version to compare from */
+  from: string;
+  /** Version to compare to */
+  to: string;
+  /** Whether to compare file contents using SHA-256 hashes. Defaults to true. */
+  includeFileHashes?: boolean;
+  /** Concurrency for file reads when computing hashes. Defaults to 5. */
+  concurrency?: number;
+  /**
+   * Comparison mode determining how files are fetched.
+   *
+   * - "prefer-local" (default): Try local first, fall back to API if not found
+   * - "local": Only use local files, fail if not present
+   * - "api": Only use API, never check local files
+   * - ["fromMode", "toMode"]: Tuple specifying different modes for from/to versions
+   *
+   * @default "prefer-local"
+   */
+  mode?: ComparisonMode;
+}
+/**
+ * Change type for modified files.
+ * - "content-changed": File content differs (hash mismatch)
+ * - "size-only-changed": Only size differs (rare, usually implies content change)
+ */
+type FileChangeType = "content-changed" | "size-only-changed";
+interface FileChangeInfo {
+  /** The file path */
+  file: string;
+  /** Type of change detected */
+  changeType: FileChangeType;
+  /** File metadata from the source version */
+  from: {
+    /** File size in bytes */size: number; /** Content hash (SHA-256, computed without UCD header) */
+    hash: string;
+  };
+  /** File metadata from the target version */
+  to: {
+    /** File size in bytes */size: number; /** Content hash (SHA-256, computed without UCD header) */
+    hash: string;
+  };
+}
+interface VersionComparison {
+  /** The source version being compared from */
+  from: string;
+  /** The target version being compared to */
+  to: string;
+  /** Files that were added in the target version */
+  added: readonly string[];
+  /** Files that were removed from the source version */
+  removed: readonly string[];
+  /** Files that were modified between versions */
+  modified: readonly string[];
+  /** Number of files that are unchanged between versions */
+  unchanged: number;
+  /** Detailed change information for modified files */
+  changes: readonly FileChangeInfo[];
+}
+//#endregion
+//#region src/tasks/mirror.d.ts
+interface MirrorOptions extends SharedOperationOptions {
+  /**
+   * Specific versions to mirror. If not provided, mirrors all manifest versions.
+   */
+  versions?: string[];
+  /**
+   * Whether to re-download files even if they already exist locally.
+   * @default false
+   */
+  force?: boolean;
+  /**
+   * Maximum concurrent downloads
+   * @default 5
+   */
+  concurrency?: number;
+}
+interface MirrorFilesReport {
+  /**
+   * List of successfully downloaded files.
+   */
+  downloaded: ReportFile[];
+  /**
+   * List of skipped files (already existed locally).
+   */
+  skipped: ReportFile[];
+  /**
+   * List of failed files.
+   */
+  failed: ReportFile[];
+}
+interface MirrorVersionReport extends BaseVersionReport {
+  /**
+   * Categorized file lists.
+   */
+  files: MirrorFilesReport;
+}
+interface MirrorReport extends BaseOperationReport {
+  /**
+   * Per-version mirror results.
+   */
+  versions: Map<string, MirrorVersionReport>;
+}
+//#endregion
+//#region src/tasks/sync.d.ts
+interface SyncOptions extends SharedOperationOptions {
+  /**
+   * Specific versions to sync. If not provided, syncs all versions in lockfile.
+   */
+  versions?: string[];
+  /**
+   * Whether to re-download files even if they already exist locally.
+   * @default false
+   */
+  force?: boolean;
+  /**
+   * Maximum concurrent downloads
+   * @default 5
+   */
+  concurrency?: number;
+  /**
+   * Remove versions from lockfile that are not available in API.
+   * @default false
+   */
+  removeUnavailable?: boolean;
+  /**
+   * Remove orphaned files (files not in expected files list for each version).
+   * @default false
+   */
+  cleanOrphaned?: boolean;
+}
+/**
+ * Complete sync report.
+ * Extends BaseOperationReport for consistency with analyze/mirror.
+ */
+interface SyncResult extends BaseOperationReport {
+  /**
+   * Versions that were added to the lockfile.
+   */
+  added: string[];
+  /**
+   * Versions that were removed from the lockfile (if removeUnavailable was true).
+   */
+  removed: string[];
+  /**
+   * Versions that were already in the lockfile.
+   */
+  unchanged: string[];
+  /**
+   * All versions in lockfile after sync.
+   */
+  versions: string[];
+  /**
+   * Report of mirrored files (same structure as mirror operation).
+   * Always present (uses empty report when no mirroring occurred).
+   */
+  mirrorReport: MirrorReport;
+  /**
+   * Files that were removed per version (orphaned files, only if cleanOrphaned was true).
+   * Always present (empty Map when no files removed).
+   */
+  removedFiles: Map<string, ReportFile[]>;
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Strategy for handling version conflicts when manifest exists and versions are provided.
+ */
+type VersionConflictStrategy = "strict" | "merge" | "overwrite";
+/**
+ * Context available during bridge construction after endpoint discovery.
+ */
+interface DiscoveryContext {
+  /**
+   * The resolved base URL for the API.
+   */
+  baseUrl: string;
+  /**
+   * The discovered endpoint configuration.
+   */
+  endpointConfig: UCDWellKnownConfig;
+  /**
+   * The resolved versions from config (if available).
+   */
+  versions: string[];
+}
+/**
+ * Helper type to extract the options type from a FileSystemBridgeFactory.
+ * Returns the first argument type, or `never` if the factory takes no arguments.
+ */
+type ExtractBridgeOptions<TSchema extends z.ZodType> = FileSystemBridgeArgs<TSchema>[0];
+type FsOptionsInputFn<TSchema extends z.ZodType> = (ctx: DiscoveryContext) => ExtractBridgeOptions<TSchema>;
+/**
+ * Input type for fsOptions - can be static options or a function receiving DiscoveryContext.
+ */
+type FsOptionsInput<TSchema extends z.ZodType> = [ExtractBridgeOptions<TSchema>] extends [never] ? never : ExtractBridgeOptions<TSchema> | FsOptionsInputFn<TSchema>;
+interface UCDStoreOptions<BridgeOptionsSchema extends z.ZodType = z.ZodUnknown> {
+  /**
+   * Base URL for the Unicode API
+   *
+   * @default "https://api.ucdjs.dev"
+   */
+  baseUrl?: string;
+  /**
+   * Optional pre-initialized UCD client instance.
+   * If provided, this client will be used instead of creating a new one.
+   * The baseUrl and endpointConfig options will be ignored if a client is provided.
+   */
+  client?: UCDClient;
+  /**
+   * Optional endpoint configuration for the UCD API.
+   * If not provided, will use default configuration or discover from API.
+   */
+  endpointConfig?: UCDWellKnownConfig;
+  /**
+   * Optional filters to apply when fetching Unicode data.
+   * These can be used to limit the data fetched from the API.
+   */
+  globalFilters?: PathFilterOptions;
+  /**
+   * File System Bridge to use for file operations.
+   * You can either provide your own implementation or use one of the following:
+   * - `@ucdjs/fs-bridge/bridges/node` for Node.js environments with full capabilities
+   * - `@ucdjs/fs-bridge/bridges/http` for HTTP-based file systems (read-only)
+   */
+  fs: FileSystemBridgeFactory<BridgeOptionsSchema>;
+  /**
+   * Options to pass to the File System Bridge factory.
+   * Can be static options or a function that receives the discovery context.
+   *
+   * TODO:
+   * When using the function form, the options has some typing issues.
+   * E.g. the function allows unspecified properties that are not in the schema.
+   * This should be fixed to strictly enforce the schema shape.
+   */
+  fsOptions?: FsOptionsInput<BridgeOptionsSchema>;
+  /**
+   * List of Unicode versions to include in the store.
+   * Only used when initializing a new store that supports mirroring.
+   */
+  versions?: string[];
+  /**
+   * Whether to require an existing store with a lockfile.
+   * If true (default), store creation will fail if no lockfile is found.
+   * Set to false to automatically initialize a new lockfile when one doesn't exist.
+   *
+   * @default true
+   */
+  requireExistingStore?: boolean;
+  /**
+   * Whether to verify lockfile versions against the API.
+   * If true, will check that all versions in the lockfile are still available.
+   * Only applies when a lockfile already exists.
+   *
+   * @default true
+   */
+  verify?: boolean;
+  /**
+   * Strategy for handling version conflicts when lockfile exists and versions are provided.
+   * - "strict": Throw error if provided versions differ from lockfile (default)
+   * - "merge": Combine lockfile and provided versions, update lockfile
+   * - "overwrite": Replace lockfile versions with provided versions, update lockfile
+   *
+   * Only applies when lockfile exists and versions are provided.
+   *
+   * @default "strict"
+   */
+  versionStrategy?: VersionConflictStrategy;
+}
+/**
+ * Internal store context to be passed
+ *
+ * @internal
+ */
+interface InternalUCDStoreContext {
+  /**
+   * UCD API client instance.
+   */
+  client: UCDClient;
+  /**
+   * Path filter to apply when fetching files.
+   */
+  filter: PathFilter;
+  /**
+   * File system bridge for file operations.
+   */
+  fs: FileSystemBridge;
+  /**
+   * Lockfile-related state and configuration.
+   */
+  lockfile: {
+    /**
+     * Whether the file system bridge supports lockfile operations (write capability).
+     */
+    supports: boolean;
+    /**
+     * Whether a lockfile currently exists.
+     */
+    exists: boolean;
+    /**
+     * Path to the store lockfile.
+     * Empty string if lockfile is not supported.
+     */
+    path: string;
+  };
+  /**
+   * Version sources and resolution.
+   */
+  versions: {
+    /**
+     * The versions that were provided as input to createUCDStore.
+     * Empty array if no versions were explicitly provided.
+     */
+    userProvided: readonly string[];
+    /**
+     * The versions from the resolved endpoint configuration.
+     * Empty array if no config was available.
+     */
+    configFile: readonly string[];
+    /**
+     * Getter that lazily fetches and caches available versions from the API.
+     * Returns a frozen array of version strings.
+     */
+    apiVersions: () => Promise<readonly string[]>;
+    /**
+     * The currently resolved/effective versions used for operations.
+     */
+    resolved: string[];
+  };
+  /**
+   * Retrieves the expected files for a specific Unicode version from the API.
+   *
+   * @param version - The Unicode version to get expected files for
+   * @returns A promise that resolves to an array of ExpectedFile objects
+   */
+  getExpectedFilePaths: (version: string) => Promise<ExpectedFile[]>;
+}
+type UCDStoreContext = Readonly<Pick<InternalUCDStoreContext, "fs">> & {
+  /**
+   * List of Unicode versions available in the store.
+   */
+  versions: readonly string[];
+};
+interface UCDStore extends UCDStoreContext, UCDStoreOperations {}
+/**
+ * Options for store methods that support filtering
+ */
+interface SharedOperationOptions {
+  /**
+   * Additional filters to apply on top of global filters
+   */
+  filters?: Pick<PathFilterOptions, "include" | "exclude">;
+}
+/**
+ * File operations namespace for the store.
+ * Provides methods for accessing and manipulating Unicode data files.
+ */
+interface UCDStoreFileOperations {
+  /**
+   * Get a specific file for a Unicode version.
+   * Tries local FS first, then falls back to API.
+   */
+  get: (version: string, path: string, options?: GetFileOptions) => Promise<OperationResult<string, StoreError>>;
+  /**
+   * List all file paths for a Unicode version.
+   * Returns a flat array of file paths.
+   */
+  list: (version: string, options?: ListFilesOptions) => Promise<OperationResult<string[], StoreError>>;
+  /**
+   * Get the file tree structure for a Unicode version.
+   * Returns a hierarchical tree of files and directories.
+   */
+  tree: (version: string, options?: GetFileTreeOptions) => Promise<OperationResult<UnicodeFileTreeNode[], StoreError>>;
+}
+interface UCDStoreOperations {
+  /**
+   * Synchronizes the store lockfile with available versions from API and mirrors files.
+   * Updates lockfile with new versions, downloads missing files, and optionally removes orphaned files/unavailable versions.
+   *
+   * Example: Fetches available versions from API, updates lockfile, mirrors files, and optionally cleans up orphaned files.
+   */
+  sync: (options?: SyncOptions) => Promise<OperationResult<SyncResult, StoreError>>;
+  /**
+   * Mirrors Unicode data files from the API to local storage.
+   * This is a file-level operation that downloads actual Unicode data for specified versions.
+   *
+   * Example: Downloads all .txt files for version 16.0.0 to local storage.
+   */
+  mirror: (options?: MirrorOptions) => Promise<OperationResult<MirrorReport, StoreError>>;
+  /**
+   * Analyzes Unicode data in the store.
+   * Returns a report with per-version analysis including file categorization,
+   * counts, metrics, and errors.
+   */
+  analyze: (options?: AnalyzeOptions) => Promise<OperationResult<AnalysisReport, StoreError>>;
+  /**
+   * Compares two Unicode versions and returns a detailed diff report.
+   * Identifies added, removed, and modified files between versions.
+   * Uses content hashes (with Unicode header stripped) to detect actual changes.
+   */
+  compare: (options?: CompareOptions) => Promise<OperationResult<VersionComparison, StoreError>>;
+  /**
+   * File operations namespace
+   */
+  files: UCDStoreFileOperations;
+}
+interface ReportFile {
+  /**
+   * The normalized file name (without version prefix).
+   */
+  name: string;
+  /**
+   * The full local file path (including version prefix).
+   */
+  filePath: string;
+}
+interface ReportError extends ReportFile {
+  /**
+   * The error message or reason for failure.
+   */
+  reason: string;
+}
+interface OperationMetrics {
+  /**
+   * Success rate as a percentage (0-100).
+   */
+  successRate: number;
+  /**
+   * Cache hit rate (skipped) as a percentage (0-100).
+   */
+  cacheHitRate: number;
+  /**
+   * Failure rate as a percentage (0-100).
+   */
+  failureRate: number;
+  /**
+   * Average milliseconds per file processed.
+   */
+  averageTimePerFile: number;
+}
+interface StorageMetrics {
+  /**
+   * Human-readable total size of all processed files.
+   */
+  totalSize: string;
+  /**
+   * Average file size (human-readable).
+   */
+  averageFileSize: string;
+}
+interface FileCounts {
+  /**
+   * Total number of files queued/expected for processing.
+   */
+  total: number;
+  /**
+   * Number of files successfully processed (downloaded/present).
+   */
+  success: number;
+  /**
+   * Number of files skipped (already existed locally).
+   */
+  skipped: number;
+  /**
+   * Number of files that failed.
+   */
+  failed: number;
+}
+interface OperationSummary {
+  /**
+   * Total operation duration in milliseconds.
+   */
+  duration: number;
+  /**
+   * File counts.
+   */
+  counts: FileCounts;
+  /**
+   * Computed metrics (rates, averages).
+   */
+  metrics: OperationMetrics;
+  /**
+   * Storage metrics (sizes).
+   */
+  storage: StorageMetrics;
+}
+interface BaseOperationReport {
+  /**
+   * ISO timestamp when the operation completed.
+   */
+  timestamp: string;
+  /**
+   * Summary of the operation.
+   * Always present (use zeroed values when no work was done).
+   */
+  summary: OperationSummary;
+}
+interface BaseVersionReport {
+  /**
+   * The Unicode version this report is for.
+   */
+  version: string;
+  /**
+   * File counts for this version.
+   */
+  counts: FileCounts;
+  /**
+   * Computed metrics for this version.
+   */
+  metrics: OperationMetrics;
+  /**
+   * Errors encountered during processing.
+   * Always present (empty array when no errors).
+   */
+  errors: ReportError[];
+}
+//#endregion
+//#region src/factory.d.ts
+interface NodeUCDStoreOptions<BridgeOptionsSchema extends z.ZodType> extends Omit<UCDStoreOptions<BridgeOptionsSchema>, "fs" | "fsOptions"> {
+  basePath?: string;
+}
+/**
+ * Creates a UCD store backed by the Node.js FileSystemBridge.
+ * @template BridgeOptionsSchema extends z.ZodType
+ * @param {NodeUCDStoreOptions<BridgeOptionsSchema>} [options] Store options; provide basePath to set the filesystem root.
+ * @returns {Promise<UCDStore>} A ready-to-use store instance.
+ * @throws {Error} If the Node.js FileSystemBridge could not be loaded.
+ */
+declare function createNodeUCDStore<BridgeOptionsSchema extends z.ZodType>(options?: NodeUCDStoreOptions<BridgeOptionsSchema>): Promise<UCDStore>;
+interface HTTPUCDStoreOptions<BridgeOptionsSchema extends z.ZodType> extends Omit<UCDStoreOptions<BridgeOptionsSchema>, "fs" | "fsOptions"> {
+  bridgeBaseUrl?: string;
+}
+/**
+ * Creates a UCD store backed by the HTTP FileSystemBridge.
+ * @template BridgeOptionsSchema extends z.ZodType
+ * @param {HTTPUCDStoreOptions<BridgeOptionsSchema>} [options] Store options; provide baseUrl to override the default.
+ * @returns {Promise<UCDStore>} A ready-to-use store instance.
+ * @throws {Error} If the HTTP FileSystemBridge could not be loaded.
+ */
+declare function createHTTPUCDStore<BridgeOptionsSchema extends z.ZodType>(options?: HTTPUCDStoreOptions<BridgeOptionsSchema>): Promise<UCDStore>;
+//#endregion
+//#region src/store.d.ts
+declare function createUCDStore<BridgeOptionsSchema extends z.ZodType>(options: UCDStoreOptions<BridgeOptionsSchema>): Promise<UCDStore>;
+//#endregion
+//#region src/utils/validate.d.ts
+interface ValidateVersionsOptions {
+  /**
+   * UCD Client instance to use for API requests.
+   */
+  client: UCDClient;
+  /**
+   * Versions to validate against the API.
+   */
+  versions: string[];
+}
+interface ValidateVersionsResult {
+  /**
+   * Whether all provided versions are valid (present in the API).
+   */
+  valid: boolean;
+  /**
+   * Versions that were validated.
+   */
+  validatedVersions: string[];
+  /**
+   * Versions available from the API.
+   */
+  availableVersions: string[];
+  /**
+   * Versions that are valid (present in the API).
+   */
+  validVersions: string[];
+  /**
+   * Versions that are invalid (not present in the API).
+   */
+  invalidVersions: string[];
+}
+/**
+ * Validates that the provided versions are available in the API.
+ * This is a pure validation function with no lockfile dependency.
+ *
+ * @param {ValidateVersionsOptions} options - Validation options
+ * @returns {Promise<ValidateVersionsResult>} Validation result
+ * @throws {UCDStoreGenericError} If API fetch fails
+ */
+declare function validateVersions(options: ValidateVersionsOptions): Promise<ValidateVersionsResult>;
+//#endregion
+export { type AnalysisFilesReport, type AnalysisReport, type AnalysisVersionReport, type AnalyzeOptions, type BaseOperationReport, type BaseVersionReport, type CompareOptions, type ComparisonMode, type FileChangeInfo, type FileChangeType, type FileCounts, type InternalUCDStoreContext, type MirrorFilesReport, type MirrorOptions, type MirrorReport, type MirrorVersionReport, type OperationMetrics, type OperationSummary, type ReportError, type ReportFile, type SharedOperationOptions, type SingleModeType, type StorageMetrics, type StoreError, type SyncOptions, type SyncResult, type UCDStore, UCDStoreBaseError, UCDStoreBridgeUnsupportedOperation, type UCDStoreContext, UCDStoreFileNotFoundError, UCDStoreGenericError, type UCDStoreOperations, type UCDStoreOptions, UCDStoreVersionNotFoundError, type ValidateVersionsOptions, type ValidateVersionsResult, type VersionComparison, type VersionConflictStrategy, createHTTPUCDStore, createNodeUCDStore, createUCDStore, validateVersions };