@based/schema 5.0.0-alpha.9 → 5.0.1

package/dist/def/typeDef.js

@@ -1,55 +1,108 @@
 import { isPropType, getPropType, } from '../index.js';
-import { setByPath } from '@saulx/utils';
-import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, } from './types.js';
+import { setByPath } from '@based/utils';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, NUMBER, BLOCK_CAPACITY_MAX, BLOCK_CAPACITY_DEFAULT, BLOCK_CAPACITY_MIN, ALIAS, ALIASES, VECTOR, COLVEC, } from './types.js';
 import { DEFAULT_MAP } from './defaultMap.js';
-import { makePacked } from './makePacked.js';
 import { makeSeparateTextSort } from './makeSeparateTextSort.js';
 import { makeSeparateSort } from './makeSeparateSort.js';
-import { getPropLen } from './getPropLen.js';
-import { isSeparate } from './utils.js';
+import { getPropLen, isSeparate, parseMinMaxStep, schemaVectorBaseTypeToEnum, } from './utils.js';
 import { addEdges } from './addEdges.js';
 import { createEmptyDef } from './createEmptyDef.js';
-import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
 import { fillEmptyMain, isZeroes } from './fillEmptyMain.js';
 import { defaultValidation, VALIDATION_MAP } from './validation.js';
-export const DEFAULT_BLOCK_CAPACITY = 100_000;
-export const updateTypeDefs = (schema, schemaTypesParsed, schemaTypesParsedById) => {
-    for (const field in schemaTypesParsed) {
-        if (field in schema.types) {
+export const updateTypeDefs = (schema) => {
+    const schemaTypesParsed = {};
+    const schemaTypesParsedById = {};
+    for (const typeName in schemaTypesParsed) {
+        if (typeName in schema.types) {
             continue;
         }
-        const id = schemaTypesParsed[field].id;
-        delete schemaTypesParsed[field];
+        const id = schemaTypesParsed[typeName].id;
+        delete schemaTypesParsed[typeName];
         delete schemaTypesParsedById[id];
     }
-    for (const field in schema.types) {
-        const type = schema.types[field];
-        if (schemaTypesParsed[field] &&
-            schemaTypesParsed[field].checksum === hashObjectIgnoreKeyOrder(type) // bit weird..
-        ) {
-            continue;
+    for (const typeName in schema.types) {
+        const type = schema.types[typeName];
+        if (!type.id) {
+            throw new Error('NEED ID ON TYPE');
         }
-        else {
-            if (!type.id) {
-                throw new Error('NEED ID ON TYPE');
+        const def = createSchemaTypeDef(typeName, type, schemaTypesParsed, schema.locales ?? {
+            en: {},
+        });
+        schemaTypesParsed[typeName] = def;
+        schemaTypesParsedById[type.id] = def;
+    }
+    // Update inverseProps in references
+    for (const schema of Object.values(schemaTypesParsed)) {
+        for (const prop of Object.values(schema.props)) {
+            if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+                if (!prop.__isEdge) {
+                    const dstType = schemaTypesParsed[prop.inverseTypeName];
+                    prop.inverseTypeId = dstType.id;
+                    prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
+                }
             }
-            const def = createSchemaTypeDef(field, type, schemaTypesParsed, schema.locales ?? {
-                en: {},
-            });
-            def.blockCapacity =
-                field === '_root' ? 2147483647 : DEFAULT_BLOCK_CAPACITY; // TODO this should come from somewhere else
-            schemaTypesParsed[field] = def;
-            schemaTypesParsedById[type.id] = def;
         }
     }
+    return { schemaTypesParsed, schemaTypesParsedById };
 };
+function propIndexOffset(prop) {
+    if (!prop.separate) {
+        return 0;
+    }
+    switch (prop.typeIndex) {
+        case REFERENCES:
+        case REFERENCE:
+            return -300;
+        case ALIAS:
+        case ALIASES:
+        case COLVEC:
+            return 300;
+        default:
+            return 0;
+    }
+}
+function reorderProps(props) {
+    props.sort((a, b) => a.prop + propIndexOffset(a) - (b.prop + propIndexOffset(b)));
+    // Reassign prop indices
+    let lastProp = 0;
+    for (const p of props) {
+        if (p.separate) {
+            p.prop = ++lastProp;
+        }
+    }
+}
 export const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmptyDef(typeName, type, locales), path = [], top = true) => {
-    if (result.id == 0 && top) {
-        if ('id' in type) {
-            result.id = type.id;
+    if (top) {
+        if (result.id == 0) {
+            if ('id' in type) {
+                result.id = type.id;
+            }
+            else {
+                throw new Error(`Invalid schema type id ${result.type}`);
+            }
         }
-        else {
-            throw new Error(`Invalid schema type id ${result.type}`);
+        if (result.blockCapacity == 0) {
+            if ('blockCapacity' in type) {
+                if (typeof type.blockCapacity !== 'number' ||
+                    type.blockCapacity < BLOCK_CAPACITY_MIN ||
+                    type.blockCapacity > BLOCK_CAPACITY_MAX) {
+                    throw new Error('Invalid blockCapacity');
+                }
+                result.blockCapacity = type.blockCapacity;
+            }
+            else {
+                result.blockCapacity =
+                    typeName === '_root' ? BLOCK_CAPACITY_MAX : BLOCK_CAPACITY_DEFAULT;
+            }
+        }
+        if (result.insertOnly == false && 'insertOnly' in type) {
+            result.insertOnly = !!type.insertOnly;
+        }
+        if (result.partial == false && 'partial' in type) {
+            result.partial = !!type.partial;
+        }
+        if ('hooks' in type) {
+            result.hooks = type.hooks;
         }
     }
     result.locales = locales;
@@ -57,8 +110,6 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
     result.idUint8[0] = result.id & 255;
     result.idUint8[1] = result.id >> 8;
     const target = type.props;
-    let separateSortProps = 0;
-    let separateSortText = 0;
     for (const key in target) {
         // Create prop def
         const schemaProp = target[key];
@@ -75,15 +126,20 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 if (typeof schemaProp === 'object') {
                     if (!(schemaProp.maxBytes < 61) ||
                         !('max' in schemaProp && schemaProp.max < 31)) {
-                        separateSortProps++;
+                        result.separateSortProps++;
                     }
                 }
                 else {
-                    separateSortProps++;
+                    result.separateSortProps++;
                 }
             }
             else if (isPropType('text', schemaProp)) {
-                separateSortText++;
+                result.separateSortText++;
+            }
+            else if (isPropType('colvec', schemaProp)) {
+                if (!result.insertOnly) {
+                    throw new Error('colvec requires insertOnly');
+                }
             }
             const isseparate = isSeparate(schemaProp, len);
             const typeIndex = TYPE_INDEX_MAP[propType];
@@ -93,16 +149,27 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 separate: isseparate,
                 path: propPath,
                 start: 0,
-                validation: schemaProp.validate ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
+                validation: schemaProp.validation ??
+                    VALIDATION_MAP[typeIndex] ??
+                    defaultValidation,
                 len,
                 default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
                 prop: isseparate ? ++result.cnt : 0,
             };
-            if (schemaProp.max) {
-                prop.max = schemaProp.max;
+            if (schemaProp.max !== undefined) {
+                prop.max = parseMinMaxStep(schemaProp.max);
             }
-            if (schemaProp.min) {
-                prop.min = schemaProp.min;
+            if (schemaProp.min !== undefined) {
+                prop.min = parseMinMaxStep(schemaProp.min);
+            }
+            if (schemaProp.step !== undefined) {
+                prop.step = parseMinMaxStep(schemaProp.step);
+            }
+            if (prop.typeIndex !== NUMBER && prop.step === undefined) {
+                prop.step = 1;
+            }
+            if (prop.typeIndex === VECTOR || prop.typeIndex === COLVEC) {
+                prop.vectorBaseType = schemaVectorBaseTypeToEnum(schemaProp.baseType ?? 'number');
             }
             if (isPropType('enum', schemaProp)) {
                 prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
@@ -112,12 +179,18 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 }
             }
             else if (isPropType('references', schemaProp)) {
+                if (result.partial) {
+                    throw new Error('references is not supported with partial');
+                }
                 prop.inversePropName = schemaProp.items.prop;
                 prop.inverseTypeName = schemaProp.items.ref;
                 prop.dependent = schemaProp.items.dependent;
                 addEdges(prop, schemaProp.items);
             }
             else if (isPropType('reference', schemaProp)) {
+                if (result.partial) {
+                    throw new Error('reference is not supported with partial');
+                }
                 prop.inversePropName = schemaProp.prop;
                 prop.inverseTypeName = schemaProp.ref;
                 prop.dependent = schemaProp.dependent;
@@ -153,24 +226,26 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
     if (top) {
         // Put top level together
         const vals = Object.values(result.props);
-        vals.sort((a, b) => {
-            if (b.separate &&
-                (a.typeIndex === REFERENCES || a.typeIndex === REFERENCE)) {
-                return -1;
-            }
-            return a.prop - b.prop;
-        });
-        let lastProp = 0;
-        for (const p of vals) {
-            if (p.separate) {
-                p.prop = ++lastProp;
-            }
-        }
+        reorderProps(vals);
         let len = 2;
+        let biggestSeperatePropDefault = 0;
         for (const f of vals) {
             if (f.separate) {
                 len += 2;
                 setByPath(result.tree, f.path, f);
+                if (f.default !== undefined) {
+                    result.hasSeperateDefaults = true;
+                    if (!result.separateDefaults) {
+                        result.separateDefaults = {
+                            props: new Map(),
+                            bufferTmp: new Uint8Array(),
+                        };
+                    }
+                    result.separateDefaults.props.set(f.prop, f);
+                    if (f.prop > biggestSeperatePropDefault) {
+                        biggestSeperatePropDefault = f.prop;
+                    }
+                }
             }
             else {
                 if (!result.mainLen) {
@@ -182,13 +257,15 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 setByPath(result.tree, f.path, f);
             }
         }
+        if (result.hasSeperateDefaults) {
+            result.separateDefaults.bufferTmp = new Uint8Array(biggestSeperatePropDefault + 1);
+        }
         result.mainEmpty = fillEmptyMain(vals, result.mainLen);
         result.mainEmptyAllZeroes = isZeroes(result.mainEmpty);
-        makePacked(result, typeName, vals, len);
-        if (separateSortText > 0) {
+        if (result.separateSortText > 0) {
             makeSeparateTextSort(result);
         }
-        if (separateSortProps > 0) {
+        if (result.separateSortProps > 0) {
             makeSeparateSort(result);
         }
         for (const p in result.props) {

package/dist/def/typeIndexes.d.ts

@@ -0,0 +1,40 @@
+export declare const NULL = 0;
+export declare const TIMESTAMP = 1;
+export declare const NUMBER = 4;
+export declare const CARDINALITY = 5;
+export declare const INT8 = 20;
+export declare const UINT8 = 6;
+export declare const INT16 = 21;
+export declare const UINT16 = 22;
+export declare const INT32 = 23;
+export declare const UINT32 = 7;
+export declare const BOOLEAN = 9;
+export declare const ENUM = 10;
+export declare const STRING = 11;
+export declare const TEXT = 12;
+export declare const REFERENCE = 13;
+export declare const REFERENCES = 14;
+export declare const WEAK_REFERENCE = 15;
+export declare const WEAK_REFERENCES = 16;
+export declare const MICRO_BUFFER = 17;
+export declare const ALIAS = 18;
+export declare const ALIASES = 19;
+export declare const BINARY = 25;
+export declare const ID = 26;
+export declare const VECTOR = 27;
+export declare const JSON = 28;
+export declare const OBJECT = 29;
+export declare const COLVEC = 30;
+export type TypeIndex = typeof NULL | typeof TIMESTAMP | typeof NUMBER | typeof CARDINALITY | typeof INT8 | typeof UINT8 | typeof INT16 | typeof UINT16 | typeof INT32 | typeof UINT32 | typeof BOOLEAN | typeof ENUM | typeof STRING | typeof TEXT | typeof REFERENCE | typeof REFERENCES | typeof WEAK_REFERENCE | typeof WEAK_REFERENCES | typeof MICRO_BUFFER | typeof ALIAS | typeof ALIASES | typeof BINARY | typeof ID | typeof VECTOR | typeof JSON | typeof OBJECT | typeof COLVEC;
+export declare enum VectorBaseType {
+    Int8 = 1,
+    Uint8 = 2,
+    Int16 = 3,
+    Uint16 = 4,
+    Int32 = 5,
+    Uint32 = 6,
+    Float32 = 7,
+    Float64 = 8
+}
+export declare const isNumberType: (type: TypeIndex) => boolean;
+//# sourceMappingURL=typeIndexes.d.ts.map

package/dist/def/typeIndexes.js

@@ -0,0 +1,50 @@
+// WARN: The following type codes are used in js and zig but selva has its own typing.
+export const NULL = 0;
+export const TIMESTAMP = 1;
+export const NUMBER = 4;
+export const CARDINALITY = 5;
+export const INT8 = 20;
+export const UINT8 = 6;
+export const INT16 = 21;
+export const UINT16 = 22;
+export const INT32 = 23;
+export const UINT32 = 7;
+export const BOOLEAN = 9;
+export const ENUM = 10;
+export const STRING = 11;
+export const TEXT = 12;
+export const REFERENCE = 13;
+export const REFERENCES = 14;
+export const WEAK_REFERENCE = 15;
+export const WEAK_REFERENCES = 16;
+export const MICRO_BUFFER = 17;
+export const ALIAS = 18;
+export const ALIASES = 19;
+export const BINARY = 25;
+export const ID = 26;
+export const VECTOR = 27;
+export const JSON = 28;
+export const OBJECT = 29;
+export const COLVEC = 30;
+export var VectorBaseType;
+(function (VectorBaseType) {
+    VectorBaseType[VectorBaseType["Int8"] = 1] = "Int8";
+    VectorBaseType[VectorBaseType["Uint8"] = 2] = "Uint8";
+    VectorBaseType[VectorBaseType["Int16"] = 3] = "Int16";
+    VectorBaseType[VectorBaseType["Uint16"] = 4] = "Uint16";
+    VectorBaseType[VectorBaseType["Int32"] = 5] = "Int32";
+    VectorBaseType[VectorBaseType["Uint32"] = 6] = "Uint32";
+    VectorBaseType[VectorBaseType["Float32"] = 7] = "Float32";
+    VectorBaseType[VectorBaseType["Float64"] = 8] = "Float64";
+})(VectorBaseType || (VectorBaseType = {}));
+export const isNumberType = (type) => {
+    return (type === NUMBER ||
+        type === UINT16 ||
+        type === UINT32 ||
+        type === INT16 ||
+        type === INT32 ||
+        type == UINT8 ||
+        type === INT8 ||
+        type === CARDINALITY);
+};
+//# sourceMappingURL=typeIndexes.js.map

package/dist/def/types.d.ts

@@ -1,56 +1,19 @@
-import type { LangCode, SchemaLocales } from '../index.js';
+import type { LangCode, SchemaHooks, SchemaLocales } from '../index.js';
 import { Validation } from './validation.js';
-export declare const NULL = 0;
-export declare const TIMESTAMP = 1;
-export declare const NUMBER = 4;
-export declare const CARDINALITY = 5;
-export declare const INT8 = 20;
-export declare const UINT8 = 6;
-export declare const INT16 = 21;
-export declare const UINT16 = 22;
-export declare const INT32 = 23;
-export declare const UINT32 = 7;
-export declare const BOOLEAN = 9;
-export declare const ENUM = 10;
-export declare const STRING = 11;
-export declare const TEXT = 12;
-export declare const REFERENCE = 13;
-export declare const REFERENCES = 14;
-export declare const WEAK_REFERENCE = 15;
-export declare const WEAK_REFERENCES = 16;
-export declare const MICRO_BUFFER = 17;
-export declare const ALIAS = 18;
-export declare const ALIASES = 19;
-export declare const BINARY = 25;
-export declare const ID = 26;
-export declare const VECTOR = 27;
-export declare const JSON = 28;
-export declare const TYPE_INDEX_MAP: {
-    alias: number;
-    aliases: number;
-    microbuffer: number;
-    references: number;
-    reference: number;
-    timestamp: number;
-    boolean: number;
-    number: number;
-    string: number;
-    text: number;
-    uint16: number;
-    uint32: number;
-    int16: number;
-    int32: number;
-    uint8: number;
-    enum: number;
-    int8: number;
-    id: number;
-    binary: number;
-    vector: number;
-    cardinality: number;
-    json: number;
-};
+import { TypeIndex, VectorBaseType } from './typeIndexes.js';
+export * from './typeIndexes.js';
+export declare const TYPE_INDEX_MAP: Record<string, TypeIndex>;
+export declare const enum numberTypes {
+    number = 4,
+    uint16 = 22,
+    uint32 = 7,
+    int16 = 21,
+    int32 = 23,
+    uint8 = 6,
+    int8 = 20,
+    cardinality = 5
+}
 export type InternalSchemaProp = keyof typeof TYPE_INDEX_MAP;
-export type TypeIndex = (typeof TYPE_INDEX_MAP)[InternalSchemaProp];
 export type PropDef = {
     __isPropDef: true;
     prop: number;
@@ -68,7 +31,10 @@ export type PropDef = {
     dependent?: boolean;
     validation: Validation;
     default: any;
+    vectorBaseType?: VectorBaseType;
+    vectorSize?: number;
     edgeMainLen?: 0;
+    hasDefaultEdges?: boolean;
     reverseEnum?: {
         [key: string]: number;
     };
@@ -84,8 +50,9 @@ export type PropDef = {
     };
     edgeMainEmpty?: Uint8Array;
     __isEdge?: boolean;
-    max?: number;
-    min?: number;
+    max?: any;
+    min?: any;
+    step?: any;
 };
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
@@ -112,17 +79,20 @@ export type SchemaSortUndefinedHandler = {
     bufferTmp: Uint8Array;
     props: PropDef[];
 };
+export declare const BLOCK_CAPACITY_MIN = 1025;
+export declare const BLOCK_CAPACITY_MAX = 2147483647;
+export declare const BLOCK_CAPACITY_DEFAULT = 100000;
 export type SchemaTypeDef = {
     cnt: number;
     checksum: number;
-    total: number;
     type: string;
     lastId: number;
     blockCapacity: number;
     mainLen: number;
+    insertOnly: boolean;
+    partial: boolean;
     buf: Uint8Array;
     propNames: Uint8Array;
-    packed: Uint8Array;
     props: {
         [path: string]: PropDef;
     };
@@ -138,19 +108,28 @@ export type SchemaTypeDef = {
     mainEmpty: Uint8Array;
     mainEmptyAllZeroes: boolean;
     tree: SchemaPropTree;
+    separateSortProps: number;
+    separateSortText: number;
     hasSeperateSort: boolean;
-    seperateSort: SchemaSortUndefinedHandler;
+    separateSort: SchemaSortUndefinedHandler;
     hasSeperateTextSort: boolean;
-    seperateTextSort: SchemaSortUndefinedHandler & {
+    separateTextSort: SchemaSortUndefinedHandler & {
         noUndefined: Uint8Array;
         localeStringToIndex: Map<string, Uint8Array>;
         localeToIndex: Map<LangCode, number>;
     };
+    hasSeperateDefaults: boolean;
+    separateDefaults?: {
+        props: Map<number, PropDef>;
+        bufferTmp: Uint8Array;
+    };
     createTs?: PropDef[];
     updateTs?: PropDef[];
     locales: Partial<SchemaLocales>;
     localeSize: number;
+    hooks?: SchemaHooks;
 };
+export declare const VECTOR_BASE_TYPE_SIZE_MAP: Record<VectorBaseType, number>;
 export declare const SIZE_MAP: Record<InternalSchemaProp, number>;
 export declare const REVERSE_SIZE_MAP: Record<TypeIndex, number>;
 export declare const REVERSE_TYPE_INDEX_MAP: Record<TypeIndex, InternalSchemaProp>;

package/dist/def/types.js

@@ -1,29 +1,5 @@
-// WARN: The following type codes are used in js and zig but selva has its own typing.
-export const NULL = 0;
-export const TIMESTAMP = 1;
-export const NUMBER = 4;
-export const CARDINALITY = 5;
-export const INT8 = 20;
-export const UINT8 = 6;
-export const INT16 = 21;
-export const UINT16 = 22;
-export const INT32 = 23;
-export const UINT32 = 7;
-export const BOOLEAN = 9;
-export const ENUM = 10;
-export const STRING = 11;
-export const TEXT = 12;
-export const REFERENCE = 13;
-export const REFERENCES = 14;
-export const WEAK_REFERENCE = 15;
-export const WEAK_REFERENCES = 16;
-export const MICRO_BUFFER = 17;
-export const ALIAS = 18;
-export const ALIASES = 19;
-export const BINARY = 25;
-export const ID = 26;
-export const VECTOR = 27;
-export const JSON = 28;
+import { ALIAS, ALIASES, BINARY, BOOLEAN, CARDINALITY, COLVEC, ENUM, INT16, INT32, INT8, JSON, MICRO_BUFFER, NULL, NUMBER, OBJECT, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, VectorBaseType, } from './typeIndexes.js';
+export * from './typeIndexes.js';
 export const TYPE_INDEX_MAP = {
     alias: ALIAS,
     aliases: ALIASES,
@@ -47,6 +23,21 @@ export const TYPE_INDEX_MAP = {
     vector: VECTOR,
     cardinality: CARDINALITY,
     json: JSON,
+    object: OBJECT,
+    colvec: COLVEC,
+};
+export const BLOCK_CAPACITY_MIN = 1025;
+export const BLOCK_CAPACITY_MAX = 2147483647;
+export const BLOCK_CAPACITY_DEFAULT = 100_000;
+export const VECTOR_BASE_TYPE_SIZE_MAP = {
+    [VectorBaseType.Int8]: 1,
+    [VectorBaseType.Uint8]: 1,
+    [VectorBaseType.Int16]: 2,
+    [VectorBaseType.Uint16]: 2,
+    [VectorBaseType.Int32]: 4,
+    [VectorBaseType.Uint32]: 4,
+    [VectorBaseType.Float32]: 4,
+    [VectorBaseType.Float64]: 8,
 };
 export const SIZE_MAP = {
     timestamp: 8, // 64bit
@@ -72,18 +63,21 @@ export const SIZE_MAP = {
     binary: 0,
     vector: 0, // separate
     json: 0,
+    object: 0,
+    colvec: 0, // separate
 };
 const reverseMap = {};
 for (const k in TYPE_INDEX_MAP) {
     reverseMap[TYPE_INDEX_MAP[k]] = k;
 }
+// @ts-ignore
 export const REVERSE_SIZE_MAP = {};
 for (const k in SIZE_MAP) {
     REVERSE_SIZE_MAP[TYPE_INDEX_MAP[k]] = SIZE_MAP[k];
 }
 export const REVERSE_TYPE_INDEX_MAP = reverseMap;
 export const ID_FIELD_DEF = {
-    typeIndex: TYPE_INDEX_MAP['id'],
+    typeIndex: NULL,
     separate: true,
     path: ['id'],
     start: 0,
@@ -94,7 +88,7 @@ export const ID_FIELD_DEF = {
     __isPropDef: true,
 };
 export const EMPTY_MICRO_BUFFER = {
-    typeIndex: TYPE_INDEX_MAP['microbuffer'],
+    typeIndex: MICRO_BUFFER,
     separate: true,
     path: [''],
     start: 0,

package/dist/def/utils.d.ts

@@ -1,7 +1,9 @@
-import { PropDef, PropDefEdge } from './types.js';
-import { SchemaProp } from '../types.js';
+import { PropDef, PropDefEdge, VectorBaseType } from './types.js';
+import { SchemaProp, SchemaVectorBaseType } from '../types.js';
 export declare function isSeparate(schemaProp: SchemaProp, len: number): boolean;
 export declare const propIsSigned: (prop: PropDef | PropDefEdge) => boolean;
 export declare const propIsNumerical: (prop: PropDef | PropDefEdge) => boolean;
-export declare function getPropLen(schemaProp: SchemaProp): any;
+export declare const schemaVectorBaseTypeToEnum: (vector: SchemaVectorBaseType) => VectorBaseType;
+export declare function getPropLen(schemaProp: SchemaProp): number;
+export declare const parseMinMaxStep: (val: any) => string | number;
 //# sourceMappingURL=utils.d.ts.map