@based/schema 5.0.0-alpha.8 → 5.0.0

package/dist/def/addEdges.js

@@ -1,7 +1,11 @@
 import { getPropType } from '../index.js';
-import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, } from './types.js';
-import { getPropLen, isSeparate } from './utils.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { fillEmptyMain } from './fillEmptyMain.js';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, NUMBER, } from './types.js';
+import { getPropLen, isSeparate, parseMinMaxStep } from './utils.js';
+import { defaultValidation, VALIDATION_MAP } from './validation.js';
 export const addEdges = (prop, refProp) => {
+    const mainEdges = [];
     for (const key in refProp) {
         if (key[0] === '$') {
             if (!prop.edges) {
@@ -18,17 +22,39 @@ export const addEdges = (prop, refProp) => {
             if (separate) {
                 prop.edgesSeperateCnt++;
             }
+            const typeIndex = TYPE_INDEX_MAP[edgeType];
+            if (edgeProp.default !== undefined) {
+                prop.hasDefaultEdges = true;
+            }
+            // add default
             const edge = {
                 __isPropDef: true,
                 __isEdge: true,
                 prop: separate ? prop.edgesSeperateCnt : 0,
+                validation: edgeProp.validation ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
                 name: key,
-                typeIndex: TYPE_INDEX_MAP[edgeType],
+                typeIndex,
                 len,
                 separate,
                 path: [...prop.path, key],
+                default: edgeProp.default ?? DEFAULT_MAP[typeIndex],
                 start: prop.edgeMainLen,
             };
+            if (!separate) {
+                mainEdges.push(edge);
+            }
+            if (edgeProp.max !== undefined) {
+                edge.max = parseMinMaxStep(edgeProp.max);
+            }
+            if (edgeProp.min !== undefined) {
+                edge.min = parseMinMaxStep(edgeProp.min);
+            }
+            if (edgeProp.step !== undefined) {
+                edge.step = parseMinMaxStep(edgeProp.step);
+            }
+            if (edge.typeIndex !== NUMBER && edge.step === undefined) {
+                edge.step = 1;
+            }
             prop.edgeMainLen += edge.len;
             if (edge.typeIndex === ENUM) {
                 edge.enum = Array.isArray(refProp[key])
@@ -54,5 +80,6 @@ export const addEdges = (prop, refProp) => {
             }
         }
     }
+    prop.edgeMainEmpty = fillEmptyMain(mainEdges, prop.edgeMainLen);
 };
 //# sourceMappingURL=addEdges.js.map

package/dist/def/createEmptyDef.d.ts

@@ -2,13 +2,15 @@ import { SchemaLocales, SchemaObject, StrictSchemaType } from '../types.js';
 export declare const createEmptyDef: (typeName: string, type: StrictSchemaType | SchemaObject, locales: Partial<SchemaLocales>) => {
     cnt: number;
     blockCapacity: number;
+    insertOnly: boolean;
+    partial: boolean;
     checksum: number;
     type: string;
     props: {};
     reverseProps: {};
-    idUint8: Uint8Array;
+    idUint8: Uint8Array<ArrayBuffer>;
     id: number;
-    mainEmpty: Uint8Array;
+    mainEmpty: Uint8Array<ArrayBuffer>;
     mainLen: number;
     separate: any[];
     tree: {};
@@ -16,21 +18,23 @@ export declare const createEmptyDef: (typeName: string, type: StrictSchemaType |
     lastId: number;
     locales: {};
     main: {};
+    separateSortProps: number;
+    separateSortText: number;
     localeSize: number;
     hasSeperateSort: boolean;
-    seperateSort: {
+    separateSort: {
         size: number;
         props: any[];
-        buffer: Uint8Array;
-        bufferTmp: Uint8Array;
+        buffer: Uint8Array<ArrayBuffer>;
+        bufferTmp: Uint8Array<ArrayBuffer>;
     };
     hasSeperateTextSort: boolean;
-    seperateTextSort: {
+    separateTextSort: {
         size: number;
         props: any[];
-        buffer: Uint8Array;
-        noUndefined: Uint8Array;
-        bufferTmp: Uint8Array;
+        buffer: Uint8Array<ArrayBuffer>;
+        noUndefined: Uint8Array<ArrayBuffer>;
+        bufferTmp: Uint8Array<ArrayBuffer>;
         localeStringToIndex: Map<any, any>;
         localeToIndex: Map<any, any>;
     };

package/dist/def/createEmptyDef.js

@@ -1,8 +1,10 @@
-import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+import { hashObjectIgnoreKeyOrder } from '@based/hash';
 export const createEmptyDef = (typeName, type, locales) => {
     return {
         cnt: 0,
         blockCapacity: 0,
+        insertOnly: false,
+        partial: false,
         checksum: hashObjectIgnoreKeyOrder(type),
         type: typeName,
         props: {},
@@ -18,16 +20,18 @@ export const createEmptyDef = (typeName, type, locales) => {
         lastId: 0,
         locales: {},
         main: {},
+        separateSortProps: 0,
+        separateSortText: 0,
         localeSize: 0,
         hasSeperateSort: false,
-        seperateSort: {
+        separateSort: {
             size: 0,
             props: [],
             buffer: new Uint8Array([]),
             bufferTmp: new Uint8Array([]),
         },
         hasSeperateTextSort: false,
-        seperateTextSort: {
+        separateTextSort: {
             size: 0, // prop len
             props: [],
             buffer: new Uint8Array([]),

package/dist/def/defaultMap.d.ts

@@ -0,0 +1,3 @@
+import { TypeIndex } from './types.js';
+export declare const DEFAULT_MAP: Record<TypeIndex, any>;
+//# sourceMappingURL=defaultMap.d.ts.map

package/dist/def/defaultMap.js

@@ -0,0 +1,31 @@
+import { ALIAS, BINARY, JSON, BOOLEAN, CARDINALITY, TIMESTAMP, INT16, INT32, INT8, UINT8, UINT16, UINT32, NUMBER, ENUM, ID, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, ALIASES, VECTOR, COLVEC, WEAK_REFERENCE, WEAK_REFERENCES, NULL, OBJECT, } from './types.js';
+export const DEFAULT_MAP = {
+    [NULL]: 0,
+    [OBJECT]: 0,
+    [WEAK_REFERENCE]: 0,
+    [WEAK_REFERENCES]: 0,
+    [ALIAS]: '',
+    [BINARY]: new Uint8Array(),
+    [BOOLEAN]: false,
+    [CARDINALITY]: [],
+    [NUMBER]: 0,
+    [TIMESTAMP]: 0,
+    [ENUM]: 0,
+    [ID]: 0,
+    [INT16]: 0,
+    [INT32]: 0,
+    [INT8]: 0,
+    [UINT8]: 0,
+    [UINT16]: 0,
+    [UINT32]: 0,
+    [JSON]: null,
+    [MICRO_BUFFER]: undefined,
+    [REFERENCE]: undefined,
+    [REFERENCES]: [],
+    [STRING]: '',
+    [ALIASES]: [],
+    [TEXT]: {},
+    [VECTOR]: undefined, // maybe not can set a vec with 0
+    [COLVEC]: undefined, // maybe not can set a vec with 0
+};
+//# sourceMappingURL=defaultMap.js.map

package/dist/def/fillEmptyMain.d.ts

@@ -1,5 +1,5 @@
-import { PropDef } from './types.js';
+import { PropDef, PropDefEdge } from './types.js';
 export declare const ENCODER: TextEncoder;
-export declare const fillEmptyMain: (vals: PropDef[], mainLen: number) => Uint8Array;
+export declare const fillEmptyMain: (vals: (PropDef | PropDefEdge)[], mainLen: number) => Uint8Array<ArrayBuffer>;
 export declare const isZeroes: (buf: Uint8Array) => boolean;
 //# sourceMappingURL=fillEmptyMain.d.ts.map

package/dist/def/fillEmptyMain.js

@@ -1,5 +1,5 @@
-import { BINARY, BOOLEAN, CREATED, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, } from './types.js';
-// Lets add validation of values in here - need to validate DEFAULT!
+import { convertToTimestamp, writeInt64 } from '@based/utils';
+import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from './types.js';
 export const ENCODER = new TextEncoder();
 export const fillEmptyMain = (vals, mainLen) => {
     const mainEmpty = new Uint8Array(mainLen);
@@ -10,8 +10,14 @@ export const fillEmptyMain = (vals, mainLen) => {
         const t = f.typeIndex;
         const s = f.start;
         let val = f.default;
-        if (t === BOOLEAN || t === INT8 || t === UINT8 || t === ENUM) {
-            mainEmpty[s] = val === true ? 1 : 0;
+        if (t === ENUM) {
+            mainEmpty[s] = f.default ?? 0;
+        }
+        else if (t === INT8 || t === UINT8) {
+            mainEmpty[s] = val;
+        }
+        else if (t === BOOLEAN) {
+            mainEmpty[s] = val ? 1 : 0;
         }
         else if (t === UINT32 || t === INT32) {
             mainEmpty[s] = val;
@@ -23,10 +29,10 @@ export const fillEmptyMain = (vals, mainLen) => {
             mainEmpty[s] = val;
             mainEmpty[s + 1] = val >>>= 8;
         }
-        else if (t === NUMBER ||
-            t === TIMESTAMP ||
-            t === CREATED ||
-            t === UPDATED) {
+        else if (t === TIMESTAMP) {
+            writeInt64(mainEmpty, convertToTimestamp(val), s);
+        }
+        else if (t === NUMBER) {
             const view = new DataView(mainEmpty.buffer, s, 8);
             view.setFloat64(0, val, true);
         }

package/dist/def/index.d.ts

@@ -2,6 +2,7 @@ export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
 export * from './selvaBuffer.js';
-export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/def/index.js

@@ -3,6 +3,7 @@ export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
 export * from './selvaBuffer.js';
-export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
 //# sourceMappingURL=index.js.map

package/dist/def/makeSeparateSort.js

@@ -11,17 +11,17 @@ export function makeSeparateSort(result) {
             }
         }
     }
-    result.seperateSort.buffer = new Uint8Array(max + 1);
+    result.separateSort.buffer = new Uint8Array(max + 1);
     for (const f of result.separate) {
         if (f.typeIndex === STRING ||
             f.typeIndex === ALIAS ||
             f.typeIndex === CARDINALITY) {
-            result.seperateSort.buffer[f.prop] = 1;
-            result.seperateSort.props.push(f);
-            result.seperateSort.size++;
+            result.separateSort.buffer[f.prop] = 1;
+            result.separateSort.props.push(f);
+            result.separateSort.size++;
         }
     }
-    result.seperateSort.bufferTmp = new Uint8Array(max + 1);
-    result.seperateSort.buffer.set(result.seperateSort.bufferTmp);
+    result.separateSort.bufferTmp = new Uint8Array(max + 1);
+    result.separateSort.buffer.set(result.separateSort.bufferTmp);
 }
 //# sourceMappingURL=makeSeparateSort.js.map

package/dist/def/makeSeparateTextSort.js

@@ -11,28 +11,28 @@ export function makeSeparateTextSort(result) {
         }
     }
     const bufLen = (max + 1) * (result.localeSize + 1);
-    result.seperateTextSort.buffer = new Uint8Array(bufLen);
+    result.separateTextSort.buffer = new Uint8Array(bufLen);
     let index = 0;
     for (const code in result.locales) {
         const codeLang = langCodesMap.get(code);
-        result.seperateTextSort.localeStringToIndex.set(code, new Uint8Array([index + 1, codeLang]));
-        result.seperateTextSort.localeToIndex.set(codeLang, index + 1);
+        result.separateTextSort.localeStringToIndex.set(code, new Uint8Array([index + 1, codeLang]));
+        result.separateTextSort.localeToIndex.set(codeLang, index + 1);
         index++;
     }
     for (const f of result.separate) {
         if (f.typeIndex === TEXT) {
             const index = f.prop * (result.localeSize + 1);
-            result.seperateTextSort.buffer[index] = result.localeSize;
-            for (const [, locales] of result.seperateTextSort.localeStringToIndex) {
-                result.seperateTextSort.buffer[locales[0] + index] = locales[1];
+            result.separateTextSort.buffer[index] = result.localeSize;
+            for (const [, locales] of result.separateTextSort.localeStringToIndex) {
+                result.separateTextSort.buffer[locales[0] + index] = locales[1];
             }
-            result.seperateTextSort.props.push(f);
-            result.seperateTextSort.size += result.localeSize;
+            result.separateTextSort.props.push(f);
+            result.separateTextSort.size += result.localeSize;
         }
     }
-    result.seperateTextSort.props.sort((a, b) => (a.prop > b.prop ? 1 : -1));
-    result.seperateTextSort.bufferTmp = new Uint8Array(bufLen);
-    result.seperateTextSort.bufferTmp.fill(0);
-    result.seperateTextSort.bufferTmp.set(result.seperateTextSort.buffer);
+    result.separateTextSort.props.sort((a, b) => (a.prop > b.prop ? 1 : -1));
+    result.separateTextSort.bufferTmp = new Uint8Array(bufLen);
+    result.separateTextSort.bufferTmp.fill(0);
+    result.separateTextSort.bufferTmp.set(result.separateTextSort.buffer);
 }
 //# sourceMappingURL=makeSeparateTextSort.js.map

package/dist/def/refSet.d.ts

@@ -0,0 +1,7 @@
+export default class RefSet {
+    #private;
+    add(srcType: number, srcField: number, dstType: number, dstField: number): boolean;
+    clear(): void;
+    values(): SetIterator<number>;
+}
+//# sourceMappingURL=refSet.d.ts.map

package/dist/def/refSet.js

@@ -0,0 +1,25 @@
+const packOne = (nodeType, field) => ((nodeType & 0xffff) << 8) | (field & 0xff);
+const packTwo = (a, b) => (a << 24) | (b & 0xffffff);
+const makeTuple = (aType, aField, bType, bField) => {
+    const a = packOne(aType, aField);
+    const b = packOne(bType, bField);
+    return a < b ? packTwo(a, b) : packTwo(b, a);
+};
+export default class RefSet {
+    #s = new Set();
+    add(srcType, srcField, dstType, dstField) {
+        const t = makeTuple(srcType, srcField, dstType, dstField);
+        if (this.#s.has(t)) {
+            return false;
+        }
+        this.#s.add(t);
+        return true;
+    }
+    clear() {
+        this.#s.clear();
+    }
+    values() {
+        return this.#s.values();
+    }
+}
+//# sourceMappingURL=refSet.js.map

package/dist/def/selvaBuffer.js

@@ -1,19 +1,35 @@
-import { ALIAS, ALIASES, BINARY, EMPTY_MICRO_BUFFER, CARDINALITY, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
+import { ALIAS, ALIASES, BINARY, EMPTY_MICRO_BUFFER, CARDINALITY, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, COLVEC, VECTOR_BASE_TYPE_SIZE_MAP, } from './types.js';
+import RefSet from './refSet.js';
+const selvaFieldType = {
+    NULL: 0,
+    MICRO_BUFFER: 1,
+    STRING: 2,
+    TEXT: 3,
+    REFERENCE: 4,
+    REFERENCES: 5,
+    WEAK_REFERENCE: 6,
+    WEAK_REFERENCES: 7,
+    ALIAS: 8,
+    ALIASES: 9,
+    COLVEC: 10,
+};
 const selvaTypeMap = new Uint8Array(32); // 1.2x faster than JS array
-selvaTypeMap[MICRO_BUFFER] = 1;
-selvaTypeMap[VECTOR] = 1;
-selvaTypeMap[BINARY] = 2;
-selvaTypeMap[CARDINALITY] = 2;
-selvaTypeMap[JSON] = 2;
-selvaTypeMap[STRING] = 2;
-selvaTypeMap[TEXT] = 3;
-selvaTypeMap[REFERENCE] = 4;
-selvaTypeMap[REFERENCES] = 5;
-selvaTypeMap[WEAK_REFERENCE] = 6;
-selvaTypeMap[WEAK_REFERENCES] = 7;
-selvaTypeMap[ALIAS] = 8;
-selvaTypeMap[ALIASES] = 9;
+selvaTypeMap[MICRO_BUFFER] = selvaFieldType.MICRO_BUFFER;
+selvaTypeMap[VECTOR] = selvaFieldType.MICRO_BUFFER;
+selvaTypeMap[BINARY] = selvaFieldType.STRING;
+selvaTypeMap[CARDINALITY] = selvaFieldType.STRING;
+selvaTypeMap[JSON] = selvaFieldType.STRING;
+selvaTypeMap[STRING] = selvaFieldType.STRING;
+selvaTypeMap[TEXT] = selvaFieldType.TEXT;
+selvaTypeMap[REFERENCE] = selvaFieldType.REFERENCE;
+selvaTypeMap[REFERENCES] = selvaFieldType.REFERENCES;
+selvaTypeMap[WEAK_REFERENCE] = selvaFieldType.WEAK_REFERENCE;
+selvaTypeMap[WEAK_REFERENCES] = selvaFieldType.WEAK_REFERENCES;
+selvaTypeMap[ALIAS] = selvaFieldType.ALIAS;
+selvaTypeMap[ALIASES] = selvaFieldType.ALIASES;
+selvaTypeMap[COLVEC] = selvaFieldType.COLVEC;
 const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
+const EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP = 0x80;
 function blockCapacity(blockCapacity) {
     const buf = new Uint8Array(Uint32Array.BYTES_PER_ELEMENT);
     const view = new DataView(buf.buffer);
@@ -23,10 +39,22 @@ function blockCapacity(blockCapacity) {
 function sepPropCount(props) {
     return props.filter((prop) => prop.separate).length;
 }
-function makeEdgeConstraintFlags(prop) {
-    return prop.dependent ? EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT : 0x00;
+function makeEdgeConstraintFlags(refSet, nodeTypeId, prop, dstNodeTypeId, inverseProp) {
+    let flags = 0;
+    flags |= prop.dependent ? EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT : 0x00;
+    flags |=
+        prop.typeIndex === REFERENCE &&
+            inverseProp &&
+            inverseProp.typeIndex === REFERENCES
+            ? EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP
+            : 0x00;
+    if (refSet) {
+        const x = refSet.add(nodeTypeId, prop.prop, dstNodeTypeId, inverseProp.prop);
+        flags |= x ? 0x00 : EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP;
+    }
+    return flags;
 }
-const propDefBuffer = (schema, prop, isEdge) => {
+const propDefBuffer = (refSet, nodeTypeId, schema, prop, isEdge) => {
     const type = prop.typeIndex;
     const selvaType = selvaTypeMap[type];
     if (prop.len && (type === MICRO_BUFFER || type === VECTOR)) {
@@ -36,6 +64,15 @@ const propDefBuffer = (schema, prop, isEdge) => {
         view.setUint16(1, prop.len, true);
         return [...buf];
     }
+    else if (prop.len && type === COLVEC) {
+        const buf = new Uint8Array(5);
+        const view = new DataView(buf.buffer);
+        buf[0] = selvaType;
+        const baseSize = VECTOR_BASE_TYPE_SIZE_MAP[prop.vectorBaseType];
+        view.setUint16(1, prop.len / baseSize, true); // elements
+        view.setUint16(3, baseSize, true); // element size
+        return [...buf];
+    }
     else if (type === REFERENCE || type === REFERENCES) {
         const buf = new Uint8Array(9);
         const view = new DataView(buf.buffer);
@@ -43,12 +80,10 @@ const propDefBuffer = (schema, prop, isEdge) => {
         let eschema = [];
         // @ts-ignore
         buf[0] = selvaType + 2 * !!isEdge; // field type
-        buf[1] = makeEdgeConstraintFlags(prop); // flags
+        buf[1] = makeEdgeConstraintFlags(refSet, nodeTypeId, prop, dstType.id, dstType.props[prop.inversePropName]); // flags
         view.setUint16(2, dstType.id, true); // dst_node_type
         view.setUint32(5, 0, true); // schema_len
         if (!isEdge) {
-            prop.inverseTypeId = dstType.id;
-            prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
             buf[4] = prop.inversePropNumber;
             if (prop.edges) {
                 const edgesS = Object.values(prop.edges);
@@ -66,9 +101,9 @@ const propDefBuffer = (schema, prop, isEdge) => {
                         ...props,
                     ];
                     eschema = p
-                        .map((prop) => propDefBuffer(schema, prop, true))
+                        .map((prop) => propDefBuffer(null, 0, schema, prop, true))
                         .flat(1);
-                    eschema.unshift(0, 0, 0, 0, sepPropCount(p), 0);
+                    eschema.unshift(0, 0, 0, 0, sepPropCount(p), 0, 0, 0);
                     view.setUint32(5, eschema.length, true);
                 }
             }
@@ -87,28 +122,42 @@ const propDefBuffer = (schema, prop, isEdge) => {
 };
 // TODO rewrite
 export function schemaToSelvaBuffer(schema) {
-    return Object.values(schema).map((t, i) => {
+    const refSet = new RefSet();
+    return Object.values(schema).map((t) => {
         const props = Object.values(t.props);
         const rest = [];
+        const nrFields = 1 + sepPropCount(props);
         let refFields = 0;
+        let virtualFields = 0;
+        if (nrFields >= 250) {
+            throw new Error('Too many fields');
+        }
         for (const f of props) {
             if (f.separate) {
                 if (f.typeIndex === REFERENCE || f.typeIndex === REFERENCES) {
                     refFields++;
                 }
+                else if (f.typeIndex === ALIAS ||
+                    f.typeIndex === ALIASES ||
+                    f.typeIndex === COLVEC) {
+                    // We assume that these are always the last props!
+                    virtualFields++;
+                }
                 rest.push(f);
             }
         }
         rest.sort((a, b) => a.prop - b.prop);
         return Uint8Array.from([
-            ...blockCapacity(t.blockCapacity),
-            1 + sepPropCount(props),
-            1 + refFields,
-            ...propDefBuffer(schema, {
+            ...blockCapacity(t.blockCapacity), // u32 blockCapacity
+            nrFields, // u8 nrFields
+            1 + refFields, // u8 nrFixedFields
+            virtualFields, // u8 nrVirtualFields
+            0, // u8 spare1
+            ...propDefBuffer(null, t.id, schema, {
                 ...EMPTY_MICRO_BUFFER,
                 len: t.mainLen === 0 ? 1 : t.mainLen,
             }),
-            ...rest.map((f) => propDefBuffer(schema, f)).flat(1),
+            ...rest.map((f) => propDefBuffer(refSet, t.id, schema, f)).flat(1),
         ]).buffer;
     });
 }

package/dist/def/typeDef.d.ts

@@ -1,7 +1,13 @@
 import { SchemaObject, StrictSchemaType, SchemaLocales } from '../index.js';
-import { SchemaTypeDef, SchemaTypesParsedById, SchemaTypesParsed } from './types.js';
+import { SchemaTypeDef, SchemaTypesParsed } from './types.js';
 import { StrictSchema } from '../types.js';
-export declare const DEFAULT_BLOCK_CAPACITY = 100000;
-export declare const updateTypeDefs: (schema: StrictSchema, schemaTypesParsed: SchemaTypesParsed, schemaTypesParsedById: SchemaTypesParsedById) => void;
+export declare const updateTypeDefs: (schema: StrictSchema) => {
+    schemaTypesParsed: {
+        [key: string]: SchemaTypeDef;
+    };
+    schemaTypesParsedById: {
+        [id: number]: SchemaTypeDef;
+    };
+};
 export declare const createSchemaTypeDef: (typeName: string, type: StrictSchemaType | SchemaObject, parsed: SchemaTypesParsed, locales: Partial<SchemaLocales>, result?: Partial<SchemaTypeDef>, path?: string[], top?: boolean) => SchemaTypeDef;
 //# sourceMappingURL=typeDef.d.ts.map