@based/schema 4.1.0 → 5.0.0-alpha.0

package/dist/parse/index.js

@@ -1,4 +1,4 @@
-import { INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
+import { INVALID_KEY, INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
 import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
@@ -8,33 +8,55 @@ export class SchemaParser {
     constructor(schema) {
         this.schema = schema;
     }
+    isItems;
     inQuery;
     schema;
     type;
-    parseType(type) {
-        expectObject(type);
-        this.parseProps(type.props, type);
-    }
+    path = [];
+    lvl = 0;
     parseTypes() {
+        this.path[this.lvl++] = 'types';
         const { types } = this.schema;
         expectObject(types);
         for (const type in types) {
-            this.parseType(types[type]);
+            this.lvl++;
+            if (type[0] === '_') {
+                throw new Error(INVALID_KEY);
+            }
+            this.path[this.lvl] = type;
+            expectObject(types[type]);
+            if (!('props' in types[type])) {
+                types[type] = { props: types[type] };
+            }
+            this.lvl--;
+        }
+        for (const type in types) {
+            this.path[this.lvl++] = type;
+            this.parseProps(types[type].props, types[type]);
+            this.lvl--;
         }
+        this.lvl--;
     }
     parseProps(props, schemaType = null) {
+        this.path[this.lvl++] = 'props';
         expectObject(props);
         this.type = schemaType;
         for (const key in props) {
+            if (key[0] === '_') {
+                throw new Error(INVALID_KEY);
+            }
             const prop = props[key];
-            const type = getPropType(prop);
+            const type = getPropType(prop, props, key);
+            this.path[this.lvl++] = key;
             if (type in propParsers) {
                 propParsers[type](prop, this);
             }
             else {
                 throw Error(INVALID_VALUE);
             }
+            this.lvl--;
         }
+        this.lvl--;
     }
     parseLocales() {
         const { locales } = this.schema;
@@ -60,17 +82,18 @@ export class SchemaParser {
     }
     parse() {
         expectObject(this.schema);
+        // always do types first because it removes props shorthand
+        if ('types' in this.schema) {
+            this.parseTypes();
+        }
         for (const key in this.schema) {
-            if (key === 'types') {
-                this.parseTypes();
-            }
-            else if (key === 'props') {
+            if (key === 'props') {
                 this.parseProps(this.schema.props);
             }
             else if (key === 'locales') {
                 this.parseLocales();
             }
-            else {
+            else if (key !== 'types') {
                 throw Error(UNKNOWN_PROP);
             }
         }
@@ -83,7 +106,7 @@ export const print = (schema, path) => {
         const v = obj[key];
         const padding = '  '.repeat(lvl);
         const prefix = key === Object.keys(obj)[0] ? '' : `${padding}...\n`;
-        if (lvl === depth) {
+        if (lvl === depth && lvl !== 0) {
             const err = key in obj
                 ? `${key}: ${typeof v === 'object' && v !== null && !Array.isArray(v) ? `{..}` : JSON.stringify(v)}`
                 : key;
@@ -94,39 +117,18 @@ export const print = (schema, path) => {
     });
     return lines.join('\n');
 };
-export const debug = (schema) => {
-    let curr;
-    const proxy = (obj, path = []) => {
-        const copy = {};
-        return new Proxy(obj, {
-            get(_, key) {
-                const v = obj[key];
-                curr = [...path, key];
-                if (typeof v !== 'object' || v === null) {
-                    return v;
-                }
-                copy[key] ??= proxy(obj[key], curr);
-                return copy[key];
-            },
-        });
-    };
-    const parser = new SchemaParser(proxy(schema));
-    try {
-        parser.parse();
-    }
-    catch (e) {
-        e.message += '\n\n' + print(schema, curr) + '\n';
-        e.cause = curr;
-        throw e;
-    }
-};
 export const parse = (schema) => {
+    const parser = new SchemaParser(schema);
     try {
-        new SchemaParser(schema).parse();
+        parser.parse();
+        // @ts-ignore
         return { schema };
     }
     catch (e) {
-        debug(schema);
+        const cause = parser.path.slice(0, Math.min(4, parser.lvl) + 1);
+        e.message += '\n\n' + print(schema, cause) + '\n';
+        e.cause = cause;
+        throw e;
     }
 };
 //# sourceMappingURL=index.js.map

package/dist/parse/props.js

@@ -1,10 +1,20 @@
+import { stringFormats, dateDisplays, numberDisplays, } from '../types.js';
 import { expectBoolean, expectFunction, expectObject, expectString, expectNumber, } from './assert.js';
-import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, } from './errors.js';
+import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, MISSING_TYPE, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
 import { getPropType } from './utils.js';
+let stringFormatsSet;
+let numberDisplaysSet;
+let dateDisplaysSet;
 const STUB = {};
 const shared = {
     type() { },
-    required(val) {
+    role(val) {
+        expectString(val);
+    },
+    required(val, _prop, ctx) {
+        if (ctx.isItems) {
+            throw new Error(NOT_ALLOWED_IN_ITEMS);
+        }
         expectBoolean(val);
     },
     query(val) {
@@ -28,6 +38,10 @@ const shared = {
             throw Error(TYPE_MISMATCH);
         }
     },
+    title(val) { },
+    description(val) { },
+    readOnly(val) { },
+    examples(val) { },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
@@ -46,15 +60,21 @@ function propParser(required, optional, allowShorthand) {
             throw Error(EXPECTED_OBJ);
         }
         for (const key in required) {
-            required[key](prop[key], prop, ctx);
+            ctx.path[ctx.lvl] = key;
+            const changed = required[key](prop[key], prop, ctx);
+            if (changed !== undefined) {
+                prop[key] = changed;
+            }
         }
         for (const key in prop) {
+            ctx.path[ctx.lvl] = key;
             const val = prop[key];
+            let changed;
             if (key in optional) {
-                optional[key](val, prop, ctx);
+                changed = optional[key](val, prop, ctx);
             }
             else if (key in shared) {
-                shared[key](val, prop, ctx);
+                changed = shared[key](val, prop, ctx);
             }
             else if (!(key in required)) {
                 if (key[0] === '$' && 'ref' in prop) {
@@ -64,15 +84,13 @@ function propParser(required, optional, allowShorthand) {
                     throw Error(UNKNOWN_PROP);
                 }
             }
+            if (changed !== undefined) {
+                prop[key] = changed;
+            }
         }
     };
 }
 const p = {};
-p.alias = propParser(STUB, {
-    default(val) {
-        expectString(val);
-    },
-}, 0);
 p.boolean = propParser(STUB, {
     default(val) {
         expectBoolean(val);
@@ -100,6 +118,11 @@ p.enum = propParser({
     },
 }, 1);
 const numberOpts = {
+    display(val) {
+        expectString(val);
+        numberDisplaysSet ??= new Set(numberDisplays);
+        numberDisplaysSet.has(val);
+    },
     min(val) {
         expectNumber(val);
     },
@@ -144,63 +167,6 @@ p.object = propParser({
         console.warn('TODO object default value');
     },
 });
-p.reference = propParser({
-    ref(ref, _prop, { schema }) {
-        schema.types[ref].props;
-    },
-    prop(propKey, prop, { schema, type, inQuery }) {
-        const propAllowed = type && !inQuery;
-        if (propAllowed) {
-            expectString(propKey);
-            const propPath = propKey.split('.');
-            let targetProp = schema.types[prop.ref];
-            for (const key of propPath) {
-                targetProp = targetProp.props[key];
-            }
-            if ('items' in targetProp) {
-                targetProp = targetProp.items;
-            }
-            if ('ref' in targetProp && 'prop' in targetProp) {
-                const inversePath = targetProp.prop.split('.');
-                let inverseProp = schema.types[targetProp.ref];
-                for (const key of inversePath) {
-                    inverseProp = inverseProp.props[key];
-                }
-                if ('items' in inverseProp) {
-                    inverseProp = inverseProp.items;
-                }
-                if (inverseProp === prop) {
-                    return;
-                }
-            }
-            throw Error(INVALID_VALUE);
-        }
-        if (propKey !== undefined) {
-            throw Error('ref prop not supported on root or edge p');
-        }
-    },
-}, {
-    default(val) {
-        expectString(val);
-    },
-    edge(val, prop, ctx, key) {
-        const edgeAllowed = ctx.type && !ctx.inQuery;
-        if (edgeAllowed) {
-            let t = ctx.schema.types[prop.ref].props[prop.prop];
-            t = t.items || t;
-            if (t[key]) {
-                throw Error('Edge can not be defined on both props');
-            }
-            const edgePropType = getPropType(val);
-            const inType = ctx.type;
-            ctx.type = null;
-            p[edgePropType](val, ctx);
-            ctx.type = inType;
-            return;
-        }
-        throw Error('ref edge not supported on root or edge p');
-    },
-});
 p.set = propParser({
     items(items, prop, ctx) {
         expectObject(items);
@@ -210,8 +176,10 @@ p.set = propParser({
             itemsType === 'timestamp' ||
             itemsType === 'boolean') {
             ctx.inQuery = 'query' in prop;
+            ctx.isItems = true;
             p[itemsType](items, ctx);
             ctx.inQuery = false;
+            ctx.isItems = false;
         }
         else {
             throw new Error(INVALID_VALUE);
@@ -231,8 +199,10 @@ p.references = propParser({
         const itemsType = getPropType(items);
         if (itemsType === 'reference') {
             ctx.inQuery = 'query' in prop;
+            ctx.isItems = true;
             p[itemsType](items, ctx);
             ctx.inQuery = false;
+            ctx.isItems = false;
         }
         else {
             throw new Error(INVALID_VALUE);
@@ -246,13 +216,34 @@ p.references = propParser({
         // }
     },
 });
-p.string = propParser(STUB, {
+const binaryOpts = {
     default(val) {
         expectString(val);
     },
+    format(val) {
+        expectString(val);
+        stringFormatsSet ??= new Set(stringFormats);
+        stringFormatsSet.has(val);
+    },
+    mime(val) {
+        if (Array.isArray(val)) {
+            val.forEach(expectString);
+        }
+        else {
+            expectString(val);
+        }
+    },
     maxBytes(val) {
         expectNumber(val);
     },
+    compression(val) {
+        // return the actualy string!
+        return val;
+    },
+};
+p.binary = propParser(STUB, binaryOpts, 0);
+p.string = propParser(STUB, {
+    ...binaryOpts,
     min(val) {
         expectNumber(val);
     },
@@ -275,6 +266,11 @@ p.text = propParser({
     },
 }, 0);
 p.timestamp = propParser(STUB, {
+    display(val) {
+        expectString(val);
+        dateDisplaysSet ??= new Set(dateDisplays);
+        dateDisplaysSet.has(val);
+    },
     default(val) {
         if (typeof val !== 'number' && !(val instanceof Date)) {
             throw Error(EXPECTED_DATE);
@@ -286,5 +282,101 @@ p.timestamp = propParser(STUB, {
         }
     },
 }, 0);
+p.reference = propParser({
+    ref(ref, _prop, { schema }) {
+        if (!schema.types[ref]?.props) {
+            throw Error(MISSING_TYPE);
+        }
+    },
+    prop(propKey, prop, { schema, type, inQuery, path }) {
+        const propAllowed = type && !inQuery;
+        if (propAllowed) {
+            expectString(propKey);
+            const propPath = propKey.split('.');
+            let targetProp = schema.types[prop.ref];
+            expectObject(targetProp, 'expected type');
+            let create;
+            for (const key of propPath) {
+                if (!targetProp.props[key]) {
+                    create = true;
+                    targetProp.props[key] = {};
+                }
+                targetProp = targetProp.props[key];
+            }
+            if (create) {
+                const ref = path[1];
+                let prop = '';
+                for (let i = 3; i < path.length - 1; i += 2) {
+                    prop += prop ? `.${path[i]}` : path[i];
+                }
+                targetProp.readOnly = true;
+                targetProp.items = {
+                    ref,
+                    prop,
+                };
+            }
+            if ('items' in targetProp) {
+                targetProp = targetProp.items;
+            }
+            if ('ref' in targetProp && 'prop' in targetProp) {
+                const inversePath = targetProp.prop.split('.');
+                let inverseProp = schema.types[targetProp.ref];
+                for (const key of inversePath) {
+                    inverseProp = inverseProp.props[key];
+                }
+                if (inverseProp && 'items' in inverseProp) {
+                    inverseProp = inverseProp.items;
+                }
+                if (prop === inverseProp) {
+                    return;
+                }
+            }
+            throw Error('expected inverse property');
+        }
+        if (propKey !== undefined) {
+            throw Error('ref prop not supported on root or edge p');
+        }
+    },
+}, {
+    mime: binaryOpts.mime,
+    default(val) {
+        expectString(val);
+    },
+    edge(val, prop, ctx, key) {
+        const edgeAllowed = ctx.type && !ctx.inQuery;
+        if (edgeAllowed) {
+            let t = ctx.schema.types[prop.ref].props[prop.prop];
+            t = t.items || t;
+            if (t[key] && t !== prop) {
+                throw Error('Edge can not be defined on both props');
+            }
+            const edgePropType = getPropType(val);
+            const inType = ctx.type;
+            ctx.type = null;
+            p[edgePropType](val, ctx);
+            ctx.type = inType;
+            return;
+        }
+        throw Error('ref edge not supported on root or edge property');
+    },
+    dependent(val, prop, ctx, key) {
+        expectBoolean(val);
+        const dependentAllowed = ctx.type && !ctx.inQuery;
+        if (!dependentAllowed) {
+            throw Error('ref dependency not supported on root or edge property');
+        }
+    },
+});
+p.alias = propParser(STUB, {
+    default(val) {
+        expectString(val);
+    },
+    format: binaryOpts.format,
+}, 0);
+p.hll = propParser(STUB, {
+    default(val) {
+        expectNumber(val);
+    },
+}, 0);
 export default p;
 //# sourceMappingURL=props.js.map

package/dist/parse/utils.d.ts

@@ -1,3 +1,3 @@
-import { SchemaAnyProp, SchemaPropTypes } from '../types.js';
-export declare const getPropType: (prop: SchemaAnyProp) => SchemaPropTypes;
+import { SchemaAnyProp, SchemaProps, SchemaPropTypes } from '../types.js';
+export declare const getPropType: (prop: SchemaAnyProp, props?: SchemaProps, key?: string) => SchemaPropTypes;
 //# sourceMappingURL=utils.d.ts.map

package/dist/parse/utils.js

@@ -1,6 +1,9 @@
 import { INVALID_TYPE, MISSING_TYPE } from './errors.js';
-export const getPropType = (prop) => {
+export const getPropType = (prop, props, key) => {
     if (typeof prop === 'string') {
+        if (props) {
+            props[key] = { type: prop };
+        }
         return prop;
     }
     if ('type' in prop) {
@@ -21,7 +24,13 @@ export const getPropType = (prop) => {
     if ('props' in prop) {
         return 'object';
     }
-    if ('enum' in prop || Array.isArray(prop)) {
+    if ('enum' in prop) {
+        return 'enum';
+    }
+    if (Array.isArray(prop)) {
+        if (props) {
+            props[key] = { enum: prop };
+        }
         return 'enum';
     }
     throw Error(MISSING_TYPE);

package/dist/types.d.ts

@@ -1,4 +1,15 @@
+import { LangName } from './lang.js';
+type Role = 'title' | 'source' | 'media' | string;
+export declare const numberDisplays: readonly ["short", "human", "ratio", "bytes", "euro", "dollar", "pound", "meter"];
+export declare const dateDisplays: readonly ["date", "date-time", "date-time-text", "date-time-human", "time", "time-precise"];
+export declare const stringFormats: readonly ["alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "ascii", "base32", "base58", "base64", "BIC", "btcAddress", "clike", "code", "creditCard", "css", "currency", "dataURI", "EAN", "email", "ethereumAddress", "FQDN", "hexadecimal", "hexColor", "HSL", "html", "IBAN", "identityCard", "IMEI", "IP", "IPRange", "ISBN", "ISIN", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "ISO6391", "ISO8601", "ISRC", "ISSN", "javascript", "json", "JWT", "latLong", "licensePlate", "lowercase", "luhnNumber", "MACAddress", "magnetURI", "markdown", "MD5", "mimeType", "mobilePhone", "mobilePhoneLocales", "octal", "passportNumber", "port", "postalCode", "postalCodeLocales", "python", "RFC3339", "rgbColor", "rust", "semVer", "slug", "strongPassword", "surrogatePair", "taxID", "typescript", "uppercase", "URL", "UUID", "VAT", "multiline"];
+type DateDisplay = (typeof dateDisplays)[number];
+type NumberDisplay = (typeof numberDisplays)[number] | `round-${number}`;
+type StringFormat = (typeof stringFormats)[number];
+type MimeString = 'text/html' | 'text/plain' | 'text/markdown' | 'image/png' | 'image/jpeg' | 'video/mp4' | 'video/quicktime' | 'image/*' | 'video/*' | 'audio/*' | '*/*' | `${string}/${string}`;
+type Mime = MimeString | MimeString[];
 type Letter = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type AllowedKey = `${Letter}${string}`;
 type QueryFn = Function;
 type PropValues = {
     type?: string;
@@ -6,19 +17,25 @@ type PropValues = {
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
-    label?: Record<string, string>;
-    description?: Record<string, string>;
+    title?: string | Record<string, string>;
+    description?: string | Record<string, string>;
     path?: string;
     query?: QueryFn;
+    role?: Role;
+    readOnly?: boolean;
+    examples?: string[];
 } & V;
 type EnumItem = string | number | boolean;
+type NeverInItems = {
+    required?: never;
+};
 export type SchemaReferences = Prop<{
     type?: 'references';
-    items: SchemaReference;
+    items: SchemaReference & NeverInItems;
 }>;
 export type SchemaReferencesOneWay = Prop<{
     type?: 'references';
-    items: SchemaReferenceOneWay;
+    items: SchemaReferenceOneWay & NeverInItems;
 }>;
 export type SchemaText = Prop<{
     type: 'text';
@@ -31,6 +48,7 @@ export type SchemaNumber = Prop<{
     min?: number;
     max?: number;
     step?: number | 'any';
+    display?: NumberDisplay;
 }>;
 export type SchemaString = Prop<{
     type: 'string';
@@ -38,31 +56,44 @@ export type SchemaString = Prop<{
     maxBytes?: number;
     max?: number;
     min?: number;
+    mime?: Mime;
+    format?: StringFormat;
+    compression?: 'none' | 'deflate';
 }>;
 export type SchemaBinary = Prop<{
     type: 'binary';
     default?: ArrayBuffer;
     maxBytes?: number;
+    mime?: Mime;
+    format?: StringFormat;
 }>;
 export type SchemaBoolean = Prop<{
     type: 'boolean';
     default?: boolean;
 }>;
+export type SchemaHll = Prop<{
+    type: 'hll';
+    default?: number;
+}>;
 export type SchemaTimestamp = Prop<{
     type: 'timestamp';
     default?: number | Date;
     on?: 'create' | 'update';
+    display?: DateDisplay;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
     default?: string;
     ref: string;
+    mime?: Mime;
 }>;
 export type SchemaReference = Prop<{
     type?: 'reference';
     default?: string;
     ref: string;
     prop: string;
+    dependent?: boolean;
+    mime?: Mime;
 }> & Record<`$${string}`, SchemaPropOneWay>;
 export type SchemaObject = Prop<{
     type?: 'object';
@@ -83,43 +114,54 @@ export type SchemaEnum = Prop<{
     default?: EnumItem;
     enum: EnumItem[];
 }>;
-export type SchemaAlias = SchemaString & {
+export type SchemaAlias = Omit<SchemaString, 'type'> & {
     type: 'alias';
 };
-export type SchemaPropShorthand = 'timestamp' | 'boolean' | 'string' | 'alias' | 'text' | NumberType | EnumItem[];
-type SetItems = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaEnum;
+export type SchemaPropShorthand = 'timestamp' | 'binary' | 'boolean' | 'string' | 'alias' | 'text' | 'hll' | NumberType | EnumItem[];
+type SetItems<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaEnum | (isStrict extends true ? never : 'timestamp' | 'binary' | 'boolean' | 'string' | NumberType | EnumItem[]);
 export type SchemaSet<ItemsType extends SetItems = SetItems> = Prop<{
     type?: 'set';
     default?: ItemsType extends {
         default: any;
     } ? ItemsType['default'][] : undefined;
-    items: ItemsType;
+    items: ItemsType & NeverInItems;
 }>;
-type NonRefSchemaProps = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaSet;
-export type SchemaProp = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
-export type SchemaPropOneWay = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps;
+type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaBinary | SchemaHll | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
+export type SchemaProp<isStrict = false> = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps<isStrict> | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
+export type SchemaPropOneWay<isStrict = false> = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps<isStrict>;
 export type SchemaAnyProp = SchemaPropOneWay | SchemaProp;
 export type SchemaHook = string | Function;
-export type SchemaProps = Record<string, SchemaProp>;
-export type SchemaType = {
+export type SchemaProps<isStrict = false> = Record<AllowedKey, SchemaProp<isStrict>> & {
+    id?: never;
+};
+type GenericSchemaType<isStrict = false> = {
     hooks?: {
         create?: SchemaHook;
         update?: SchemaHook;
         delete?: SchemaHook;
     };
     id?: number;
-    props: SchemaProps;
+    props: SchemaProps<isStrict>;
+};
+export type StrictSchemaType = GenericSchemaType<true>;
+export type SchemaType<isStrict = false> = isStrict extends true ? StrictSchemaType : StrictSchemaType | GenericSchemaType<false> | (SchemaProps & {
+    props?: never;
+});
+export type SchemaTypeName = AllowedKey;
+export type SchemaTypes<isStrict = false> = Record<SchemaTypeName, SchemaType<isStrict>>;
+export type SchemaPropsOneWay<isStrict = false> = Record<AllowedKey, SchemaPropOneWay<isStrict>> & {
+    id?: never;
 };
-export type SchemaTypes = Record<string, SchemaType>;
-export type SchemaPropsOneWay = Record<`${Letter}${string}`, SchemaPropOneWay>;
-export type Schema = {
-    types?: SchemaTypes;
-    props?: SchemaPropsOneWay;
-    locales?: SchemaLocales;
+type GenericSchema<isStrict = false> = {
+    types?: SchemaTypes<isStrict>;
+    props?: SchemaPropsOneWay<isStrict>;
+    locales?: Partial<SchemaLocales>;
 };
-export type SchemaLocales = Record<string, {
+export type StrictSchema = GenericSchema<true>;
+export type Schema = GenericSchema<false> | StrictSchema;
+export type SchemaLocales = Record<LangName, {
     required?: boolean;
-    fallback?: string[];
+    fallback?: LangName[];
 }>;
 export type SchemaPropTypeMap = {
     references: SchemaReferences;
@@ -133,8 +175,9 @@ export type SchemaPropTypeMap = {
     text: SchemaText;
     set: SchemaSet;
     binary: SchemaBinary;
+    hll: SchemaHll;
 } & Record<NumberType, SchemaNumber>;
 export type SchemaPropTypes = keyof SchemaPropTypeMap;
-export declare const isPropType: <T extends "string" | "boolean" | "object" | "references" | "timestamp" | "alias" | "text" | NumberType | "binary" | "reference" | "enum" | "set">(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export declare const isPropType: <T extends SchemaPropTypes>(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
 export {};
 //# sourceMappingURL=types.d.ts.map