@fjell/core 4.4.48 → 4.4.50

package/dist/operations/wrappers/createActionWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for action() operation
+ *
+ * Provides automatic validation for action() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { ActionOperationMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped action() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated action() method
+ *
+ * @example
+ * ```typescript
+ * const action = createActionWrapper(
+ *   coordinate,
+ *   async (key, action, params) => {
+ *     return await database.executeAction(key, action, params);
+ *   }
+ * );
+ * ```
+ */
+export declare function createActionWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: ActionOperationMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): ActionOperationMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createAllActionWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for allAction() operation
+ *
+ * Provides automatic validation for allAction() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { AllActionOperationMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped allAction() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated allAction() method
+ *
+ * @example
+ * ```typescript
+ * const allAction = createAllActionWrapper(
+ *   coordinate,
+ *   async (action, params, locations) => {
+ *     return await database.executeAllAction(action, params, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createAllActionWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: AllActionOperationMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): AllActionOperationMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createAllFacetWrapper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wrapper for allFacet() operation
+ *
+ * Provides automatic validation for allFacet() operation parameters.
+ */
+import type { Coordinate } from "../../Coordinate";
+import type { AllFacetOperationMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped allFacet() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated allFacet() method
+ *
+ * @example
+ * ```typescript
+ * const allFacet = createAllFacetWrapper(
+ *   coordinate,
+ *   async (facet, params, locations) => {
+ *     return await database.executeAllFacet(facet, params, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createAllFacetWrapper<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: AllFacetOperationMethod<L1, L2, L3, L4, L5>, options?: WrapperOptions): AllFacetOperationMethod<L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createAllWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for all() operation
+ *
+ * Provides automatic validation for all() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { AllMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped all() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated all() method
+ *
+ * @example
+ * ```typescript
+ * const all = createAllWrapper(
+ *   coordinate,
+ *   async (query, locations) => {
+ *     return await database.findAll(query, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createAllWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: AllMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): AllMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createCreateWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for create() operation
+ *
+ * Provides automatic validation for create() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { CreateMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped create() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional wrapper configuration
+ * @returns A fully validated create() method
+ *
+ * @example
+ * ```typescript
+ * const create = createCreateWrapper(
+ *   coordinate,
+ *   async (item, options) => {
+ *     return await database.create(item, options);
+ *   }
+ * );
+ * ```
+ */
+export declare function createCreateWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: CreateMethod<V, S, L1, L2, L3, L4, L5>, wrapperOptions?: WrapperOptions): CreateMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createFacetWrapper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wrapper for facet() operation
+ *
+ * Provides automatic validation for facet() operation parameters.
+ */
+import type { Coordinate } from "../../Coordinate";
+import type { FacetOperationMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped facet() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated facet() method
+ *
+ * @example
+ * ```typescript
+ * const facet = createFacetWrapper(
+ *   coordinate,
+ *   async (key, facet, params) => {
+ *     return await database.executeFacet(key, facet, params);
+ *   }
+ * );
+ * ```
+ */
+export declare function createFacetWrapper<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: FacetOperationMethod<S, L1, L2, L3, L4, L5>, options?: WrapperOptions): FacetOperationMethod<S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createFindOneWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for findOne() operation
+ *
+ * Provides automatic validation for findOne() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { FindOneMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped findOne() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated findOne() method
+ *
+ * @example
+ * ```typescript
+ * const findOne = createFindOneWrapper(
+ *   coordinate,
+ *   async (finder, params, locations) => {
+ *     return await database.executeFinderOne(finder, params, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createFindOneWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: FindOneMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): FindOneMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createFindWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for find() operation
+ *
+ * Provides automatic validation for find() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { FindMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped find() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated find() method
+ *
+ * @example
+ * ```typescript
+ * const find = createFindWrapper(
+ *   coordinate,
+ *   async (finder, params, locations) => {
+ *     return await database.executeFinder(finder, params, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createFindWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: FindMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): FindMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createGetWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for get() operation
+ *
+ * Provides automatic validation for get() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { GetMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped get() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated get() method
+ *
+ * @example
+ * ```typescript
+ * const get = createGetWrapper(
+ *   coordinate,
+ *   async (key) => {
+ *     return await database.findByKey(key);
+ *   }
+ * );
+ * ```
+ */
+export declare function createGetWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: GetMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): GetMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createOneWrapper.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Wrapper for one() operation
+ *
+ * Provides automatic validation for one() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { OneMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped one() method with automatic parameter validation.
+ *
+ * The wrapper handles:
+ * - Query validation
+ * - Location array validation against coordinate
+ * - Parameter normalization (undefined → defaults)
+ * - Consistent error handling
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation (no validation needed)
+ * @param options - Optional configuration
+ * @returns A fully validated one() method
+ *
+ * @example
+ * ```typescript
+ * const one = createOneWrapper(
+ *   coordinate,
+ *   async (query, locations) => {
+ *     // Just implement the logic - validation is automatic
+ *     return await database.findOne(query, locations);
+ *   }
+ * );
+ *
+ * // Usage
+ * const item = await one({ status: 'active' }, [{ kt: 'org', lk: '123' }]);
+ * ```
+ */
+export declare function createOneWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: OneMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): OneMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createRemoveWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for remove() operation
+ *
+ * Provides automatic validation for remove() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { RemoveMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped remove() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated remove() method
+ *
+ * @example
+ * ```typescript
+ * const remove = createRemoveWrapper(
+ *   coordinate,
+ *   async (key) => {
+ *     return await database.delete(key);
+ *   }
+ * );
+ * ```
+ */
+export declare function createRemoveWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: RemoveMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): RemoveMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createUpdateWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for update() operation
+ *
+ * Provides automatic validation for update() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { UpdateMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped update() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated update() method
+ *
+ * @example
+ * ```typescript
+ * const update = createUpdateWrapper(
+ *   coordinate,
+ *   async (key, item) => {
+ *     return await database.update(key, item);
+ *   }
+ * );
+ * ```
+ */
+export declare function createUpdateWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: UpdateMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): UpdateMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/createUpsertWrapper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Wrapper for upsert() operation
+ *
+ * Provides automatic validation for upsert() operation parameters.
+ */
+import type { Item } from "../../items";
+import type { Coordinate } from "../../Coordinate";
+import type { UpsertMethod } from "../methods";
+import type { WrapperOptions } from "./types";
+/**
+ * Creates a wrapped upsert() method with automatic parameter validation.
+ *
+ * @param coordinate - The coordinate defining the item hierarchy
+ * @param implementation - The core logic for the operation
+ * @param options - Optional configuration
+ * @returns A fully validated upsert() method
+ *
+ * @example
+ * ```typescript
+ * const upsert = createUpsertWrapper(
+ *   coordinate,
+ *   async (key, item, locations) => {
+ *     return await database.upsert(key, item, locations);
+ *   }
+ * );
+ * ```
+ */
+export declare function createUpsertWrapper<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(coordinate: Coordinate<S, L1, L2, L3, L4, L5>, implementation: UpsertMethod<V, S, L1, L2, L3, L4, L5>, options?: WrapperOptions): UpsertMethod<V, S, L1, L2, L3, L4, L5>;

package/dist/operations/wrappers/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Operation wrapper functions that provide automatic parameter validation.
+ *
+ * These wrappers eliminate boilerplate validation code in Operations implementations.
+ *
+ * @example
+ * ```typescript
+ * import { createOneWrapper } from '@fjell/core';
+ *
+ * const one = createOneWrapper(
+ *   coordinate,
+ *   async (query, locations) => {
+ *     // Validation happens automatically
+ *     return await database.findOne(query, locations);
+ *   }
+ * );
+ * ```
+ *
+ * @module wrappers
+ */
+export type { WrapperOptions, ErrorContext, WrapperContext } from './types';
+export { createOneWrapper } from './createOneWrapper';
+export { createAllWrapper } from './createAllWrapper';
+export { createGetWrapper } from './createGetWrapper';
+export { createCreateWrapper } from './createCreateWrapper';
+export { createUpdateWrapper } from './createUpdateWrapper';
+export { createUpsertWrapper } from './createUpsertWrapper';
+export { createRemoveWrapper } from './createRemoveWrapper';
+export { createFindWrapper } from './createFindWrapper';
+export { createFindOneWrapper } from './createFindOneWrapper';
+export { createActionWrapper } from './createActionWrapper';
+export { createAllActionWrapper } from './createAllActionWrapper';
+export { createFacetWrapper } from './createFacetWrapper';
+export { createAllFacetWrapper } from './createAllFacetWrapper';

package/dist/operations/wrappers/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Types for operation wrappers
+ *
+ * These wrappers provide automatic parameter validation for all Operations methods.
+ */
+import type { Coordinate } from "../../Coordinate";
+/**
+ * Options for configuring wrapper behavior
+ */
+export interface WrapperOptions {
+    /**
+     * Skip automatic parameter validation.
+     * Use this if you're handling validation elsewhere.
+     * @default false
+     */
+    skipValidation?: boolean;
+    /**
+     * Custom operation name for error messages.
+     * If not provided, uses the wrapper's default name.
+     */
+    operationName?: string;
+    /**
+     * Enable debug logging for wrapper calls.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Custom error handler.
+     * If provided, catches and transforms errors from the implementation.
+     */
+    onError?: (error: Error, context: ErrorContext) => Error | never;
+}
+/**
+ * Context provided to error handlers
+ */
+export interface ErrorContext {
+    operationName: string;
+    params: any[];
+    coordinate: Coordinate<any, any, any, any, any, any>;
+}
+/**
+ * Internal context passed through wrapper execution
+ */
+export interface WrapperContext<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
+    coordinate: Coordinate<S, L1, L2, L3, L4, L5>;
+    operationName: string;
+    options: WrapperOptions;
+}

package/dist/validation/ItemValidator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Item validation
+ *
+ * Validates that Item objects have correct key types and structures.
+ */
+import type { Item } from "../items";
+import type { AllItemTypeArrays } from "../keys";
+/**
+ * Validates that an item or array of items have the correct primary key type
+ *
+ * @param input - The item or array of items to validate
+ * @param pkType - The expected primary key type
+ * @returns The validated item(s)
+ * @throws Error if any item is invalid or has wrong key type
+ *
+ * @example
+ * ```typescript
+ * // Validate single item
+ * const item = validatePK(fetchedItem, 'product');
+ *
+ * // Validate array of items
+ * const items = validatePK(fetchedItems, 'product');
+ * ```
+ */
+export declare const validatePK: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(input: Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[], pkType: S) => Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[];
+/**
+ * Validates that an item's key matches the expected key type array
+ *
+ * This is used to validate composite items where the key structure must match
+ * the complete hierarchy (e.g., [product, store, region])
+ *
+ * @param item - The item to validate
+ * @param keyTypes - The expected key type array
+ * @returns The validated item
+ * @throws Error if item is invalid or key types don't match
+ *
+ * @example
+ * ```typescript
+ * // Validate item has correct key structure
+ * const item = validateKeys(fetchedItem, ['product', 'store']);
+ * ```
+ */
+export declare const validateKeys: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: Item<S, L1, L2, L3, L4, L5>, keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>) => Item<S, L1, L2, L3, L4, L5>;

package/dist/validation/KeyValidator.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Key validation (PriKey, ComKey)
+ *
+ * Validates key structures and ensures keys match the expected library type.
+ */
+import type { ComKey, PriKey } from "../keys";
+import type { Coordinate } from "../Coordinate";
+/**
+ * Validates that a key is valid and matches the expected library type.
+ *
+ * This function performs comprehensive validation:
+ * 1. Validates key type (PriKey vs ComKey) matches library type (primary vs composite)
+ * 2. For composite keys, validates location key array order matches hierarchy
+ * 3. Validates key structure is correct
+ *
+ * @param key - The key to validate
+ * @param coordinate - The coordinate defining the library's key type hierarchy
+ * @param operation - The operation name (for error messages)
+ * @throws Error if key type doesn't match library type or location key array order is incorrect
+ *
+ * @example
+ * ```typescript
+ * // Validate a PriKey for a primary library
+ * validateKey(
+ *   { kt: 'product', pk: '123' },
+ *   coordinate,
+ *   'get'
+ * );
+ *
+ * // Validate a ComKey for a composite library
+ * validateKey(
+ *   { kt: 'product', pk: '123', loc: [{ kt: 'store', lk: '456' }] },
+ *   coordinate,
+ *   'get'
+ * );
+ * ```
+ */
+export declare const validateKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(key: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, operation: string) => void;
+/**
+ * Validates a PriKey structure
+ *
+ * @param key - The primary key to validate
+ * @param expectedType - The expected key type
+ * @param operation - The operation name (for error messages)
+ * @throws Error if key is invalid
+ */
+export declare const validatePriKey: <S extends string>(key: PriKey<S>, expectedType: S, operation: string) => void;
+/**
+ * Validates a ComKey structure
+ *
+ * @param key - The composite key to validate
+ * @param coordinate - The coordinate defining the expected hierarchy
+ * @param operation - The operation name (for error messages)
+ * @throws Error if key is invalid
+ */
+export declare const validateComKey: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(key: ComKey<S, L1, L2, L3, L4, L5>, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, operation: string) => void;

package/dist/validation/LocationValidator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Location array validation
+ *
+ * Validates that LocKeyArray parameters match the expected Coordinate hierarchy.
+ */
+import type { LocKeyArray } from "../keys";
+import type { Coordinate } from "../Coordinate";
+import type { ValidationResult } from "./types";
+/**
+ * Validates that a standalone LocKeyArray parameter matches the expected hierarchy
+ * defined by the coordinate's key type array (kta).
+ *
+ * This is used to validate the `locations` parameter passed to operations like
+ * all(), find(), create(), etc.
+ *
+ * @param locations - The location key array to validate
+ * @param coordinate - The coordinate defining the library's key type hierarchy
+ * @param operation - The operation name (for error messages)
+ * @throws Error if location key array order is incorrect
+ *
+ * @example
+ * ```typescript
+ * validateLocations(
+ *   [{kt: 'store', lk: '123'}],
+ *   coordinate,
+ *   'find'
+ * );
+ * ```
+ */
+export declare const validateLocations: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(locations: LocKeyArray<L1, L2, L3, L4, L5> | [] | undefined, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, operation: string) => void;
+/**
+ * Non-throwing version of validateLocations that returns a ValidationResult
+ *
+ * @param locations - The location key array to validate
+ * @param coordinate - The coordinate defining the library's key type hierarchy
+ * @param operation - The operation name (for error messages)
+ * @returns ValidationResult with valid flag and optional error message
+ */
+export declare const isValidLocations: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(locations: LocKeyArray<L1, L2, L3, L4, L5> | [] | undefined, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, operation: string) => ValidationResult;