@fjell/core 4.4.0 → 4.4.2

package/dist/item/IQUtils.js

@@ -0,0 +1,305 @@
+import { isPriKey, isItemKeyEqual } from '../key/KUtils.js';
+import LibLogger from '../logger.js';
+import { DateTime } from 'luxon';
+import { isCondition } from './ItemQuery.js';
+
+const logger = LibLogger.get('IQUtils');
+/**
+ * When we query or search, we're sending a GET request.  This converts everything in ItemQuery into a flat
+ * object that can be sent over a GET request.
+ *
+ * Note that there is some discussion about this.  Evidently Elastic supports search with POST, but that also
+ * feels like a bit of a hack. It's not a RESTful way to do things.  So we're sticking with GET for now.
+ *
+ * For reference, look at RFC 9110 "HTTP Semantics", June which clarified on top of and RFC 7231.  It's possible
+ * but there are so many caveats and conditions in the standard, it's not worth it.
+ *
+ * Anticipating the next question - "isn't there a limit to the length of a URL?"   The specification does not
+ * specify a limit, and there are limits in various browsers and servers - Apache is 4,000 chars, Chrome is 2M chars.
+ * Short answer is that if this query is being used to craft something that complex, it is probably a better idea
+ * to provide an action or a custom query endpoint on the server.
+ *
+ * @param query
+ * @returns QueryParams ready to be get over a GET request.
+ */ const queryToParams = (query)=>{
+    const params = {};
+    if (query.compoundCondition) {
+        params.compoundCondition = JSON.stringify(query.compoundCondition);
+    }
+    if (query.refs) {
+        params.refs = JSON.stringify(query.refs);
+    }
+    if (query.limit) {
+        params.limit = query.limit;
+    }
+    if (query.offset) {
+        params.offset = query.offset;
+    }
+    if (query.aggs) {
+        params.aggs = JSON.stringify(query.aggs);
+    }
+    if (query.events) {
+        params.events = JSON.stringify(query.events);
+    }
+    return params;
+};
+// This is a dateTimeReviver used for JSON parse - when we convert a param back to a query, we need this.
+const dateTimeReviver = function(key, value) {
+    if (typeof value === 'string') {
+        const parsedDate = DateTime.fromISO(value);
+        if (parsedDate.isValid) {
+            return parsedDate.toJSDate();
+        }
+    }
+    return value;
+};
+/**
+ * This method translates from a flat QueryParams object with stringify'd JSON back to a full ItemQuery.
+ *
+ * @param params Parameters sent over a GET request
+ * @returns A fully hydrated ItemQuery object.
+ */ const paramsToQuery = (params)=>{
+    const query = {};
+    if (params.compoundCondition) {
+        query.compoundCondition = JSON.parse(params.compoundCondition);
+    }
+    if (params.refs) {
+        query.refs = JSON.parse(params.refs);
+    }
+    if (params.limit) {
+        query.limit = Number(params.limit);
+    }
+    if (params.offset) {
+        query.offset = Number(params.offset);
+    }
+    if (params.aggs) {
+        query.aggs = JSON.parse(params.aggs);
+    }
+    if (params.events) {
+        query.events = JSON.parse(params.events, dateTimeReviver);
+    }
+    return query;
+};
+const isRefQueryMatch = (refKey, queryRef, references)=>{
+    logger.trace('doesRefMatch', {
+        queryRef,
+        references
+    });
+    logger.debug('Comparing Ref', {
+        refKey,
+        itemRef: references[refKey],
+        queryRef
+    });
+    return isItemKeyEqual(queryRef, references[refKey]);
+};
+const isCompoundConditionQueryMatch = (queryCondition, item)=>{
+    if (queryCondition.compoundType === 'AND') {
+        // If this is an AND compound condition, we need to check if all of the conditions match
+        return queryCondition.conditions.every((condition)=>isCondition(condition) ? isConditionQueryMatch(condition, item) : isCompoundConditionQueryMatch(condition, item));
+    } else {
+        // If this is an OR compound condition, we need to check if any of the conditions match
+        return queryCondition.conditions.some((condition)=>isCondition(condition) ? isConditionQueryMatch(condition, item) : isCompoundConditionQueryMatch(condition, item));
+    }
+};
+const isConditionQueryMatch = (queryCondition, item)=>{
+    const propKey = queryCondition.column;
+    logger.trace('doesConditionMatch', {
+        propKey,
+        queryCondition,
+        item
+    });
+    // eslint-disable-next-line no-undefined
+    if (item[propKey] === undefined) {
+        logger.debug('Item does not contain prop under key', {
+            propKey,
+            item
+        });
+        return false;
+    }
+    logger.debug('Comparing Condition', {
+        propKey,
+        itemProp: item[propKey],
+        queryCondition
+    });
+    let result = false;
+    switch(queryCondition.operator){
+        case '==':
+            result = item[propKey] === queryCondition.value;
+            break;
+        case '!=':
+            result = item[propKey] !== queryCondition.value;
+            break;
+        case '>':
+            result = item[propKey] > queryCondition.value;
+            break;
+        case '>=':
+            result = item[propKey] >= queryCondition.value;
+            break;
+        case '<':
+            result = item[propKey] < queryCondition.value;
+            break;
+        case '<=':
+            result = item[propKey] <= queryCondition.value;
+            break;
+        case 'in':
+            result = queryCondition.value.includes(item[propKey]);
+            break;
+        case 'not-in':
+            result = !queryCondition.value.includes(item[propKey]);
+            break;
+        case 'array-contains':
+            result = item[propKey].includes(queryCondition.value);
+            break;
+        case 'array-contains-any':
+            result = queryCondition.value.some((value)=>item[propKey].includes(value));
+            break;
+    }
+    return result;
+};
+const isAggQueryMatch = (aggKey, aggQuery, agg)=>{
+    const aggItem = agg.item;
+    logger.debug('Comparing Agg', {
+        aggKey,
+        aggItem,
+        aggQuery
+    });
+    // Fancy, right?  This is a recursive call to isQueryMatch
+    return isQueryMatch(aggItem, aggQuery);
+};
+const isEventQueryMatch = (eventKey, eventQuery, item)=>{
+    if (!item.events[eventKey]) {
+        logger.debug('Item does not contain event under key', {
+            eventKey,
+            events: item.events
+        });
+        return false;
+    } else {
+        const itemEvent = item.events[eventKey];
+        if (itemEvent.at !== null) {
+            if (eventQuery.start && !(eventQuery.start.getTime() <= itemEvent.at.getTime())) {
+                logger.debug('Item date before event start query', {
+                    eventQuery,
+                    itemEvent
+                });
+                return false;
+            }
+            if (eventQuery.end && !(eventQuery.end.getTime() > itemEvent.at.getTime())) {
+                logger.debug('Item date after event end query', {
+                    eventQuery,
+                    itemEvent
+                });
+                return false;
+            }
+        } else {
+            logger.debug('Item event does contains a null at', {
+                itemEvent
+            });
+            return false;
+        }
+        return true;
+    }
+};
+const isQueryMatch = (item, query)=>{
+    logger.trace('isMatch', {
+        item,
+        query
+    });
+    if (query.refs && item.refs) {
+        for(const key in query.refs){
+            const queryRef = query.refs[key];
+            if (!isRefQueryMatch(key, queryRef, item.refs)) return false;
+        }
+    } else if (query.refs && !item.refs) {
+        logger.debug('Query contains refs but item does not have refs', {
+            query,
+            item
+        });
+        return false;
+    }
+    if (query.compoundCondition && item) {
+        if (!isCompoundConditionQueryMatch(query.compoundCondition, item)) return false;
+    }
+    if (query.events && item.events) {
+        for(const key in query.events){
+            const queryEvent = query.events[key];
+            if (!isEventQueryMatch(key, queryEvent, item)) return false;
+        }
+        return true;
+    }
+    if (query.aggs && item.aggs) {
+        for(const key in query.aggs){
+            const aggQuery = query.aggs[key];
+            if (item.aggs[key] && !isAggQueryMatch(key, aggQuery, item.aggs[key])) return false;
+        }
+    }
+    if (query.aggs && !item.aggs) {
+        logger.debug('Query contains aggs but item does not have aggs', {
+            query,
+            item
+        });
+        return false;
+    }
+    // If it hasn't returned false by now, it must be a match
+    return true;
+};
+const abbrevQuery = (query)=>{
+    const abbrev = [
+        'IQ'
+    ];
+    if (query) {
+        if (query.refs) {
+            for(const key in query.refs){
+                const ref = abbrevRef(key, query.refs[key]);
+                abbrev.push(ref);
+            }
+        }
+        if (query.compoundCondition) {
+            const props = abbrevCompoundCondition(query.compoundCondition);
+            abbrev.push(props);
+        }
+        if (query.aggs) {
+            for(const key in query.aggs){
+                const agg = abbrevAgg(key, query.aggs[key]);
+                abbrev.push(agg);
+            }
+        }
+        if (query.events) {
+            const events = `(E${Object.keys(query.events).join(',')})`;
+            abbrev.push(events);
+        }
+        if (query.limit) {
+            abbrev.push(`L${query.limit}`);
+        }
+        if (query.offset) {
+            abbrev.push(`O${query.offset}`);
+        }
+    } else {
+        abbrev.push('(empty)');
+    }
+    return abbrev.join(' ');
+};
+const abbrevRef = (key, ref)=>{
+    if (isPriKey(ref)) {
+        const priKey = ref;
+        return `R(${key},${priKey.kt},${priKey.pk})`;
+    } else {
+        const comKey = ref;
+        return `R(${key},${JSON.stringify(comKey)})`;
+    }
+};
+const abbrevAgg = (key, agg)=>{
+    return `A(${key},${abbrevQuery(agg)})`;
+};
+const abbrevCompoundCondition = (compoundCondition)=>{
+    return `CC(${compoundCondition.compoundType},` + `${compoundCondition.conditions ? compoundCondition.conditions.map(abbrevCondition).join(',') : 'No Conditions'})`;
+};
+const abbrevCondition = (condition)=>{
+    if (isCondition(condition)) {
+        return `(${condition.column},${condition.value},${condition.operator})`;
+    } else {
+        return abbrevCompoundCondition(condition);
+    }
+};
+
+export { abbrevAgg, abbrevCompoundCondition, abbrevCondition, abbrevQuery, abbrevRef, isQueryMatch, paramsToQuery, queryToParams };
+//# sourceMappingURL=IQUtils.js.map

package/dist/item/IQUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IQUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/item/IUtils.d.ts

@@ -0,0 +1,6 @@
+import { Item } from '../items';
+import { AllItemTypeArrays } from '../keys';
+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>[];
+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>;
+export declare const isPriItem: <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>) => item is Item<S, L1, L2, L3, L4, L5>;
+export declare const isComItem: <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>) => item is Item<S, L1, L2, L3, L4, L5>;

package/dist/item/IUtils.js

@@ -0,0 +1,77 @@
+import { toKeyTypeArray, isPriKey, isComKey } from '../key/KUtils.js';
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('IUtils');
+const validatePK = (input, pkType)=>{
+    logger.trace('Checking Return Type', {
+        input
+    });
+    if (Array.isArray(input)) {
+        const itemArray = input;
+        return itemArray.map((item)=>validatePK(item, pkType));
+    } else {
+        const item = input;
+        if (item) {
+            if (item.key) {
+                const keyTypeArray = toKeyTypeArray(item.key);
+                const match = keyTypeArray[0] === pkType;
+                if (!match) {
+                    logger.error('Key Type Array Mismatch', {
+                        keyTypeArray,
+                        pkType
+                    });
+                    throw new Error('Item does not have the correct primary key type');
+                } else {
+                    return item;
+                }
+            } else {
+                logger.error('Validating PK, Item does not have a key', {
+                    item
+                });
+                throw new Error('Validating PK, Item does not have a key');
+            }
+        } else {
+            logger.error('Validating PK, Item is undefined', {
+                item
+            });
+            throw new Error('Validating PK, Item is undefined');
+        }
+    }
+};
+const validateKeys = (item, keyTypes)=>{
+    logger.trace('Checking Return Type', {
+        item
+    });
+    if (item) {
+        if (item.key) {
+            const keyTypeArray = toKeyTypeArray(item.key);
+            if (keyTypeArray.length !== keyTypes.length) {
+                throw new Error('Item does not have the correct number of keys');
+            } else {
+                const match = JSON.stringify(keyTypeArray) === JSON.stringify(keyTypes);
+                if (!match) {
+                    logger.error('Key Type Array Mismatch', {
+                        keyTypeArray,
+                        thisKeyTypes: keyTypes
+                    });
+                    throw new Error('Item does not have the correct key types');
+                } else {
+                    return item;
+                }
+            }
+        } else {
+            throw new Error('validating keys, item does not have a key: ' + JSON.stringify(item));
+        }
+    } else {
+        throw new Error('validating keys, item is undefined');
+    }
+};
+const isPriItem = (item)=>{
+    return item && item.key ? isPriKey(item.key) : false;
+};
+const isComItem = (item)=>{
+    return item && item.key ? isComKey(item.key) : false;
+};
+
+export { isComItem, isPriItem, validateKeys, validatePK };
+//# sourceMappingURL=IUtils.js.map

package/dist/item/IUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/item/ItemQuery.d.ts

@@ -0,0 +1,62 @@
+import { References } from '../items';
+export type QueryParams = Record<string, string | number | boolean | Date>;
+/**
+ * The operator for a condition.  This is the same as the operators used in the Firestore query language.
+ */
+export type ConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'not-in' | 'array-contains' | 'array-contains-any';
+/**
+ * A single property condition is defined with a column, value, and operator.
+ * This is a condition that is used in a query.
+ */
+export type Condition = {
+    column: string;
+    value: string[] | string | number[] | number | boolean | Date;
+    operator: ConditionOperator;
+};
+/**
+ * When applying a compound condition, the CompoundType defines the type of compound condition.
+ */
+export type CompoundType = 'AND' | 'OR';
+/**
+ * When configuring a CompoundCondition this can contain a collection of conditions
+ * that will be applied to the query.  By default, this is an AND conditiion that is associated
+ * with an array of Condition objects OR an array of CompoundCondition objects.
+ *
+ * For example, I could have { compoundType: 'AND', conditions: [{column: 'name', value: 'test', operator: '=='},
+ * {column: 'age', value: 21, operator: '>='}]} which would filter the query to only include items
+ * where the name is 'test' and the age is greater than or equal to 21.
+ *
+ * Or, I could have a { compoundType: 'OR', conditions: [{column: 'name', value: 'test', operator: '=='},
+ * {column: 'age', value: 21, operator: '>='}]} which would filter the query to only include items
+ * where the name is 'test' OR the age is greater than or equal to 21.
+ *
+ * I could also nest an OR within an AND, like this:
+ * ['AND', [{column: 'name', value: 'test', operator: '=='},
+ * { compoundType: 'OR', conditions: [{column: 'age', value: 21, operator: '<='},
+ * {column: 'age', value: 52, operator: '>='}]}]] which would filter the query to only include items where the
+ * name is 'test' and the age is less than or equal to 21 or greater than or equal to 52.
+ */
+export type CompoundCondition = {
+    compoundType: CompoundType;
+    conditions: Array<Condition | CompoundCondition>;
+};
+export declare const isCondition: (condition: any) => condition is Condition;
+export type EventQuery = {
+    start?: Date;
+    end?: Date;
+    by?: string;
+};
+export type OrderDirection = 'asc' | 'desc';
+export type OrderBy = {
+    field: string;
+    direction: OrderDirection;
+};
+export type ItemQuery = {
+    refs?: References;
+    compoundCondition?: CompoundCondition;
+    limit?: number;
+    offset?: number;
+    aggs?: Record<string, ItemQuery>;
+    events?: Record<string, EventQuery>;
+    orderBy?: OrderBy[];
+};

package/dist/item/ItemQuery.js

@@ -0,0 +1,6 @@
+const isCondition = (condition)=>{
+    return (typeof condition.column === 'string' && Array.isArray(condition.value) && condition.value.every((item)=>typeof item === 'string') || Array.isArray(condition.value) && condition.value.every((item)=>typeof item === 'number') || typeof condition.value === 'string' || typeof condition.value === 'number' || typeof condition.value === 'boolean' || condition.value instanceof Date) && (condition.operator ? typeof condition.operator === 'string' : true);
+};
+
+export { isCondition };
+//# sourceMappingURL=ItemQuery.js.map

package/dist/item/ItemQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemQuery.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/items.d.ts

@@ -0,0 +1,51 @@
+import { ComKey, PriKey } from './keys';
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
+};
+export type Identified<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> | PriKey<S>;
+};
+export type Propertied = {
+    [key: string]: any;
+};
+/**
+ * This is a generic item event, and it's designed to make sure we have the ability to define not just
+ * the required fields, but also the optional fields.
+ */
+export interface ItemEvent {
+    at: Date | null;
+    by?: ComKey<any, any | never, any | never, any | never, any | never, any | never> | PriKey<any>;
+    agg?: Item<any, any, any, any, any, any>;
+}
+/**
+ * This is a required item event, and it's here mainly to define that there are events that must be present.
+ */
+export interface RequiredItemEvent extends ItemEvent {
+    at: Date;
+}
+export type Evented = Record<string, ItemEvent>;
+export interface Timestamped extends Evented {
+    created: RequiredItemEvent;
+    updated: RequiredItemEvent;
+}
+export interface Deletable extends Partial<Evented> {
+    deleted: ItemEvent;
+}
+export type ManagedEvents = Timestamped & Deletable;
+export type ItemProperties<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = Omit<Item<S, L1, L2, L3, L4, L5>, 'events' | 'key'> & {
+    events?: Evented;
+};
+export type TypesProperties<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> = Omit<V, 'events' | 'key'> & {
+    events?: Evented;
+};
+export type References = Record<string, ComKey<string, string | never, string | never, string | never, string | never, string | never> | PriKey<string>>;
+export type ReferenceItem<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> | PriKey<S>;
+    item: Item<S, L1, L2, L3, L4, L5>;
+};
+export type ReferenceItems = Record<string, ReferenceItem<string, string | never, string | never, string | never, string | never, string | never>>;
+export interface Item<S extends string = never, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends Identified<S, L1, L2, L3, L4, L5>, Propertied {
+    events: ManagedEvents & Evented;
+    aggs?: ReferenceItems;
+    refs?: References;
+}

package/dist/key/KUtils.d.ts

@@ -0,0 +1,35 @@
+import { ComKey, LocKey, LocKeyArray, PriKey } from '../keys';
+export declare const isItemKeyEqual: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(a: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, b: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => boolean;
+export declare const isPriKeyEqual: <S extends string>(a: PriKey<S>, b: PriKey<S>) => boolean;
+export declare const isLocKeyEqual: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(a: LocKey<L1 | L2 | L3 | L4 | L5>, b: LocKey<L1 | L2 | L3 | L4 | L5>) => boolean;
+export declare const isComKeyEqual: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(a: ComKey<S, L1, L2, L3, L4, L5>, b: ComKey<S, L1, L2, L3, L4, L5>) => boolean;
+export declare const isItemKey: (key: any) => boolean;
+export declare const isComKey: (key: any) => boolean;
+export declare const isPriKey: (key: any) => boolean;
+export declare const isLocKey: (key: any) => boolean;
+export declare const generateKeyArray: <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> | PriKey<S> | LocKeyArray<L1, L2, L3, L4, L5> | []) => Array<PriKey<S> | LocKey<L1 | L2 | L3 | L4 | L5>>;
+export declare const constructPriKey: <S extends string>(pk: string | PriKey<S>, kt: S) => PriKey<S>;
+export declare const cPK: <S extends string>(pk: string | PriKey<S>, kt: S) => PriKey<S>;
+export declare const toKeyTypeArray: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(ik: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => string[];
+export declare const abbrevIK: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => string;
+export declare const abbrevLKA: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyArray: Array<LocKey<L1 | L2 | L3 | L4 | L5>> | null) => string;
+export declare const primaryType: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => string;
+/**
+ *
+ * @param ik ItemKey to be used as a basis for a location
+ * @returns
+ */
+export declare const itemKeyToLocKeyArray: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(ik: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => LocKeyArray<S, L1, L2, L3, L4>;
+export declare const ikToLKA: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(ik: PriKey<S> | ComKey<S, L1, L2, L3, L4, L5>) => LocKeyArray<S, L1, L2, L3, L4>;
+/**
+ * Sometimes you need to take a location key array and convert it to the item key that points to the containing item.
+ * @param lka A location key array
+ * @returns An item key corresponding to the containing item this location refers to.
+ */
+export declare const locKeyArrayToItemKey: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(lka: LocKeyArray<L1, L2, L3, L4, L5>) => PriKey<L1> | ComKey<L1, L2, L3, L4, L5>;
+export declare const isValidPriKey: <S extends string>(key: PriKey<S>) => boolean;
+export declare const isValidLocKey: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(key: LocKey<L1 | L2 | L3 | L4 | L5>) => boolean;
+export declare const isValidLocKeyArray: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(keyArray: Array<LocKey<L1 | L2 | L3 | L4 | L5>>) => boolean;
+export declare const isValidComKey: <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>) => boolean;
+export declare const isValidItemKey: <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> | PriKey<S>) => boolean;
+export declare const lkaToIK: <L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(lka: LocKeyArray<L1, L2, L3, L4, L5>) => PriKey<L1> | ComKey<L1, L2, L3, L4, L5>;