@atcute/lex-cli 1.1.2 → 2.0.0

package/src/schema.ts

@@ -1,290 +1,531 @@
 import * as v from '@badrap/valita';
 
-const integerType = v
+// tsc dislikes this schema with the amount of type expansion that happens here.
+// the interface declaration allows tsc to just reference it instead of
+// expanding on every type reference.
+
+const _integer = v
 	.number()
-	.assert((v) => Number.isInteger(v) && v >= 0, 'Number is expected to be a positive integer');
+	.assert((input) => input >= 0 && Number.isSafeInteger(input), `expected non-negative integer`);
+
+const integer = _integer as integer.$schema;
+declare namespace integer {
+	export {};
 
-export const booleanSchema = v.object({
+	type $schematype = typeof _integer;
+	export interface $schema extends $schematype {}
+}
+
+const _lexBoolean = v.object({
 	type: v.literal('boolean'),
 	description: v.string().optional(),
 	default: v.boolean().optional(),
 	const: v.boolean().optional(),
 });
 
-export type BooleanSchema = v.Infer<typeof booleanSchema>;
+export const lexBoolean = _lexBoolean as lexBoolean.$schema;
+export interface LexBoolean extends v.Infer<typeof lexBoolean> {}
+export declare namespace lexBoolean {
+	export {};
+
+	type $schematype = typeof _lexBoolean;
+	export interface $schema extends $schematype {}
+}
 
-export const integerSchema = v.object({
+const _lexInteger = v.object({
 	type: v.literal('integer'),
 	description: v.string().optional(),
-	default: integerType.optional(),
-	const: integerType.optional(),
-	enum: v.array(v.number()).optional(),
-	maximum: integerType.optional(),
-	minimum: integerType.optional(),
+	default: integer.optional(),
+	minimum: integer.optional(),
+	maximum: integer.optional(),
+	enum: v.array(integer).optional(),
+	const: integer.optional(),
 });
 
-export type IntegerSchema = v.Infer<typeof integerSchema>;
+export const lexInteger = _lexInteger as lexInteger.$schema;
+export interface LexInteger extends v.Infer<typeof lexInteger> {}
+export declare namespace lexInteger {
+	export {};
+
+	type $schematype = typeof _lexInteger;
+	export interface $schema extends $schematype {}
+}
+
+const _lexStringFormat = v.union(
+	v.literal('datetime'),
+	v.literal('uri'),
+	v.literal('at-uri'),
+	v.literal('did'),
+	v.literal('handle'),
+	v.literal('at-identifier'),
+	v.literal('nsid'),
+	v.literal('cid'),
+	v.literal('language'),
+	v.literal('tid'),
+	v.literal('record-key'),
+);
+
+export const lexStringFormat = _lexStringFormat as lexStringFormat.$schema;
+export type LexStringFormat = v.Infer<typeof lexStringFormat>;
+export declare namespace lexStringFormat {
+	export {};
+
+	type $schematype = typeof _lexStringFormat;
+	export interface $schema extends $schematype {}
+}
 
-export const stringSchema = v.object({
+const _lexString = v.object({
 	type: v.literal('string'),
+	format: lexStringFormat.optional(),
 	description: v.string().optional(),
-	format: v
-		.union(
-			v.literal('at-identifier'),
-			v.literal('at-uri'),
-			v.literal('cid'),
-			v.literal('datetime'),
-			v.literal('did'),
-			v.literal('handle'),
-			v.literal('language'),
-			v.literal('nsid'),
-			v.literal('record-key'),
-			v.literal('tid'),
-			v.literal('uri'),
-		)
-		.optional(),
 	default: v.string().optional(),
-	const: v.string().optional(),
+	minLength: integer.optional(),
+	maxLength: integer.optional(),
+	minGraphemes: integer.optional(),
+	maxGraphemes: integer.optional(),
 	enum: v.array(v.string()).optional(),
+	const: v.string().optional(),
 	knownValues: v.array(v.string()).optional(),
-	maxLength: integerType.optional(),
-	minLength: integerType.optional(),
-	maxGraphemes: integerType.optional(),
-	minGraphemes: integerType.optional(),
 });
 
-export type StringSchema = v.Infer<typeof stringSchema>;
+export const lexString = _lexString as lexString.$schema;
+export interface LexString extends v.Infer<typeof lexString> {}
+export declare namespace lexString {
+	export {};
+
+	type $schematype = typeof _lexString;
+	export interface $schema extends $schematype {}
+}
 
-export const unknownSchema = v.object({
+const _lexUnknown = v.object({
 	type: v.literal('unknown'),
 	description: v.string().optional(),
 });
 
-export type UnknownSchema = v.Infer<typeof unknownSchema>;
+export const lexUnknown = _lexUnknown as lexUnknown.$schema;
+export interface LexUnknown extends v.Infer<typeof lexUnknown> {}
+export declare namespace lexUnknown {
+	export {};
 
-export const primitiveSchema = v.union(booleanSchema, integerSchema, stringSchema, unknownSchema);
+	type $schematype = typeof _lexUnknown;
+	export interface $schema extends $schematype {}
+}
 
-export type PrimitiveSchema = v.Infer<typeof primitiveSchema>;
+const _lexPrimitive = v.union(lexBoolean, lexInteger, lexString, lexUnknown);
 
-export const bytesSchema = v.object({
+export const lexPrimitive = _lexPrimitive as lexPrimitive.$schema;
+export type LexPrimitive = v.Infer<typeof lexPrimitive>;
+export declare namespace lexPrimitive {
+	export {};
+
+	type $schematype = typeof _lexPrimitive;
+	export interface $schema extends $schematype {}
+}
+
+const _lexBytes = v.object({
 	type: v.literal('bytes'),
 	description: v.string().optional(),
-	maxLength: integerType.optional(),
-	minLength: integerType.optional(),
+	minLength: integer.optional(),
+	maxLength: integer.optional(),
 });
 
-export type BytesSchema = v.Infer<typeof bytesSchema>;
+export const lexBytes = _lexBytes as lexBytes.$schema;
+export interface LexBytes extends v.Infer<typeof lexBytes> {}
+export declare namespace lexBytes {
+	export {};
 
-export const cidLinkSchema = v.object({
+	type $schematype = typeof _lexBytes;
+	export interface $schema extends $schematype {}
+}
+
+const _lexCidLink = v.object({
 	type: v.literal('cid-link'),
 	description: v.string().optional(),
 });
 
-export type CidLinkSchema = v.Infer<typeof cidLinkSchema>;
+export const lexCidLink = _lexCidLink as lexCidLink.$schema;
+export interface LexCidLink extends v.Infer<typeof lexCidLink> {}
+export declare namespace lexCidLink {
+	export {};
+
+	type $schematype = typeof _lexCidLink;
+	export interface $schema extends $schematype {}
+}
+
+const _lexIpldType = v.union(lexBytes, lexCidLink);
+
+export const lexIpldType = _lexIpldType as lexIpldType.$schema;
+export type LexIpldType = v.Infer<typeof lexIpldType>;
+export declare namespace lexIpldType {
+	export {};
+
+	type $schematype = typeof _lexIpldType;
+	export interface $schema extends $schematype {}
+}
 
-export const ipldTypeSchema = v.union(bytesSchema, cidLinkSchema);
+const REF_RE =
+	/^(?=.)(?:[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+\.[a-zA-Z][a-zA-Z0-9]{0,62}?)?(?:#[a-zA-Z][a-zA-Z0-9_]{0,62}?)?$/;
 
-export type IpldTypeSchema = v.Infer<typeof ipldTypeSchema>;
+const refString = v.string().assert((input) => REF_RE.test(input));
 
-export const refSchema = v.object({
+const _lexRef = v.object({
 	type: v.literal('ref'),
 	description: v.string().optional(),
-	ref: v.string(),
+	ref: refString,
 });
 
-export type RefSchema = v.Infer<typeof refSchema>;
+export const lexRef = _lexRef as lexRef.$schema;
+export interface LexRef extends v.Infer<typeof lexRef> {}
+export declare namespace lexRef {
+	export {};
 
-export const refUnionSchema = v
-	.object({
-		type: v.literal('union'),
-		description: v.string().optional(),
-		refs: v.array(v.string()),
-		closed: v.boolean().optional(() => false),
-	})
-	.assert((v) => !v.closed || v.refs.length > 0, `A closed union can't have empty refs list`);
+	type $schematype = typeof _lexRef;
+	export interface $schema extends $schematype {}
+}
+
+const _lexRefUnion = v.object({
+	type: v.literal('union'),
+	description: v.string().optional(),
+	refs: v.array(refString),
+	closed: v.boolean().optional(() => false),
+});
+
+export const lexRefUnion = _lexRefUnion as lexRefUnion.$schema;
+export interface LexRefUnion extends v.Infer<typeof lexRefUnion> {}
+export declare namespace lexRefUnion {
+	export {};
 
-export type RefUnionSchema = v.Infer<typeof refUnionSchema>;
+	type $schematype = typeof _lexRefUnion;
+	export interface $schema extends $schematype {}
+}
 
-export const refVariantSchema = v.union(refSchema, refUnionSchema);
+const _lexRefVariant = v.union(lexRef, lexRefUnion);
 
-export type RefVariantSchema = v.Infer<typeof refVariantSchema>;
+export const lexRefVariant = _lexRefVariant as lexRefVariant.$schema;
+export type LexRefVariant = v.Infer<typeof lexRefVariant>;
+export declare namespace lexRefVariant {
+	export {};
 
-export const blobSchema = v.object({
+	type $schematype = typeof _lexRefVariant;
+	export interface $schema extends $schematype {}
+}
+
+const _lexBlob = v.object({
 	type: v.literal('blob'),
 	description: v.string().optional(),
 	accept: v.array(v.string()).optional(),
-	maxSize: integerType.optional(),
+	maxSize: integer.optional(),
 });
 
-export type BlobSchema = v.Infer<typeof blobSchema>;
+export const lexBlob = _lexBlob as lexBlob.$schema;
+export interface LexBlob extends v.Infer<typeof lexBlob> {}
+export declare namespace lexBlob {
+	export {};
+
+	type $schematype = typeof _lexBlob;
+	export interface $schema extends $schematype {}
+}
 
-export const arraySchema = v.object({
+const _lexArray = v.object({
 	type: v.literal('array'),
 	description: v.string().optional(),
-	items: v.union(primitiveSchema, ipldTypeSchema, blobSchema, refVariantSchema),
-	maxLength: integerType.optional(),
-	minLength: integerType.optional(),
+	items: v.union(lexPrimitive, lexIpldType, lexRefVariant, lexBlob),
+	minLength: integer.optional(),
+	maxLength: integer.optional(),
 });
 
-export type ArraySchema = v.Infer<typeof arraySchema>;
+export const lexArray = _lexArray as lexArray.$schema;
+export interface LexArray extends v.Infer<typeof lexArray> {}
+export declare namespace lexArray {
+	export {};
 
-export const primitiveArraySchema = arraySchema.extend({
-	items: primitiveSchema,
+	type $schematype = typeof _lexArray;
+	export interface $schema extends $schematype {}
+}
+
+const _lexPrimitiveArray = lexArray.extend({
+	items: lexPrimitive,
 });
 
-export type PrimitiveArraySchema = v.Infer<typeof primitiveArraySchema>;
+export const lexPrimitiveArray = _lexPrimitiveArray as lexPrimitiveArray.$schema;
+export interface LexPrimitiveArray extends v.Infer<typeof lexPrimitiveArray> {}
+export declare namespace lexPrimitiveArray {
+	export {};
+
+	type $schematype = typeof _lexPrimitiveArray;
+	export interface $schema extends $schematype {}
+}
 
-export const tokenSchema = v.object({
+const _lexToken = v.object({
 	type: v.literal('token'),
 	description: v.string().optional(),
 });
 
-export type TokenSchema = v.Infer<typeof tokenSchema>;
+export const lexToken = _lexToken as lexToken.$schema;
+export interface LexToken extends v.Infer<typeof lexToken> {}
+export declare namespace lexToken {
+	export {};
 
-const refineRequiredProperties = <T extends { required: string[]; properties: Record<string, unknown> }>(
-	obj: T,
+	type $schematype = typeof _lexToken;
+	export interface $schema extends $schematype {}
+}
+
+const KEY_RE = /^[a-zA-Z][a-zA-Z0-9_]{0,62}?$/;
+
+const refineObjectProperties = <T extends { required?: string[]; properties?: Record<string, unknown> }>(
+	input: T,
 ): v.ValitaResult<T> => {
-	for (const field of obj.required) {
-		if (obj.properties[field] === undefined) {
-			return v.err(`Required field "${field}" not defined`);
+	const { required = [], properties } = input;
+
+	for (const key in properties) {
+		if (!KEY_RE.test(key)) {
+			return v.err({
+				message: `invalid property key`,
+				path: ['properties', key],
+			});
+		}
+	}
+
+	if (required.length > 0) {
+		if (properties === undefined) {
+			return v.err({
+				message: `required fields specified but no properties defined`,
+				path: ['properties'],
+			});
+		}
+
+		for (const key of required) {
+			if (properties[key] === undefined) {
+				return v.err({
+					message: `required fields not defined`,
+					path: ['properties', key],
+				});
+			}
 		}
 	}
 
-	return v.ok(obj);
+	return v.ok(input);
 };
 
-export const objectSchema = v
+const _lexObject = v
 	.object({
 		type: v.literal('object'),
 		description: v.string().optional(),
-		required: v.array(v.string()).optional(() => []),
-		nullable: v.array(v.string()).optional(() => []),
-		properties: v.record(v.union(refVariantSchema, ipldTypeSchema, arraySchema, blobSchema, primitiveSchema)),
+		required: v.array(v.string()).optional(),
+		nullable: v.array(v.string()).optional(),
+		properties: v.record(v.union(lexArray, lexPrimitive, lexIpldType, lexRefVariant, lexBlob)).optional(),
 	})
-	.chain(refineRequiredProperties);
+	.chain(refineObjectProperties);
+
+export const lexObject = _lexObject as lexObject.$schema;
+export interface LexObject extends v.Infer<typeof lexObject> {}
+export declare namespace lexObject {
+	export {};
 
-export type ObjectSchema = v.Infer<typeof objectSchema>;
+	type $schematype = typeof _lexObject;
+	export interface $schema extends $schematype {}
+}
 
-export const xrpcParametersSchema = v
+const _lexXrpcParameters = v
 	.object({
 		type: v.literal('params'),
 		description: v.string().optional(),
-		required: v.array(v.string()).optional(() => []),
-		properties: v.record(v.union(primitiveSchema, primitiveArraySchema)),
+		required: v.array(v.string()).optional(),
+		properties: v.record(v.union(lexPrimitive, lexPrimitiveArray)).optional(),
 	})
-	.chain(refineRequiredProperties);
+	.chain(refineObjectProperties);
+
+export const lexXrpcParameters = _lexXrpcParameters as lexXrpcParameters.$schema;
+export interface LexXrpcParameters extends v.Infer<typeof lexXrpcParameters> {}
+export declare namespace lexXrpcParameters {
+	export {};
 
-export type XrpcParametersSchema = v.Infer<typeof xrpcParametersSchema>;
+	type $schematype = typeof _lexXrpcParameters;
+	export interface $schema extends $schematype {}
+}
 
-export const xrpcBodySchema = v.object({
+const _lexXrpcBody = v.object({
 	description: v.string().optional(),
 	encoding: v.string(),
-	schema: v.union(refVariantSchema, objectSchema).optional(),
+	schema: v.union(lexRefVariant, lexObject).optional(),
 });
 
-export type XrpcBodySchema = v.Infer<typeof xrpcBodySchema>;
+export const lexXrpcBody = _lexXrpcBody as lexXrpcBody.$schema;
+export interface LexXrpcBody extends v.Infer<typeof lexXrpcBody> {}
+export declare namespace lexXrpcBody {
+	export {};
 
-export const xrpcSubscriptionMessageSchema = v.object({
+	type $schematype = typeof _lexXrpcBody;
+	export interface $schema extends $schematype {}
+}
+
+const _lexXrpcSubscriptionMessage = v.object({
 	description: v.string().optional(),
-	schema: v.union(refVariantSchema, objectSchema).optional(),
+	schema: v.union(lexRefVariant, lexObject).optional(),
 });
 
-export type XrpcSubscriptionMessageSchema = v.Infer<typeof xrpcSubscriptionMessageSchema>;
+export const lexXrpcSubscriptionMessage = _lexXrpcSubscriptionMessage as lexXrpcSubscriptionMessage.$schema;
+export interface LexXrpcSubscriptionMessage extends v.Infer<typeof lexXrpcSubscriptionMessage> {}
+export declare namespace lexXrpcSubscriptionMessage {
+	export {};
+
+	type $schematype = typeof _lexXrpcSubscriptionMessage;
+	export interface $schema extends $schematype {}
+}
 
-export const xrpcErrorSchema = v.object({
+const _lexXrpcError = v.object({
 	name: v.string(),
 	description: v.string().optional(),
 });
 
-export type XrpcErrorSchema = v.Infer<typeof xrpcErrorSchema>;
+export const lexXrpcError = _lexXrpcError as lexXrpcError.$schema;
+export interface LexXrpcError extends v.Infer<typeof lexXrpcError> {}
+export declare namespace lexXrpcError {
+	export {};
 
-export const xrpcQuerySchema = v.object({
+	type $schematype = typeof _lexXrpcError;
+	export interface $schema extends $schematype {}
+}
+
+const _lexXrpcQuery = v.object({
 	type: v.literal('query'),
 	description: v.string().optional(),
-	parameters: xrpcParametersSchema.optional(),
-	output: xrpcBodySchema.optional(),
-	errors: v.array(xrpcErrorSchema).optional(),
+	parameters: lexXrpcParameters.optional(),
+	output: lexXrpcBody.optional(),
+	errors: v.array(lexXrpcError).optional(),
 });
 
-export type XrpcQuerySchema = v.Infer<typeof xrpcQuerySchema>;
+export const lexXrpcQuery = _lexXrpcQuery as lexXrpcQuery.$schema;
+export interface LexXrpcQuery extends v.Infer<typeof lexXrpcQuery> {}
+export declare namespace lexXrpcQuery {
+	export {};
+
+	type $schematype = typeof _lexXrpcQuery;
+	export interface $schema extends $schematype {}
+}
 
-export const xrpcProcedureSchema = v.object({
+const _lexXrpcProcedure = v.object({
 	type: v.literal('procedure'),
 	description: v.string().optional(),
-	parameters: xrpcParametersSchema.optional(),
-	input: xrpcBodySchema.optional(),
-	output: xrpcBodySchema.optional(),
-	errors: v.array(xrpcErrorSchema).optional(),
+	parameters: lexXrpcParameters.optional(),
+	input: lexXrpcBody.optional(),
+	output: lexXrpcBody.optional(),
+	errors: v.array(lexXrpcError).optional(),
 });
 
-export type XrpcProcedureSchema = v.Infer<typeof xrpcProcedureSchema>;
+export const lexXrpcProcedure = _lexXrpcProcedure as lexXrpcProcedure.$schema;
+export interface LexXrpcProcedure extends v.Infer<typeof lexXrpcProcedure> {}
+export declare namespace lexXrpcProcedure {
+	export {};
 
-export const xrpcSubscriptionSchema = v.object({
+	type $schematype = typeof _lexXrpcProcedure;
+	export interface $schema extends $schematype {}
+}
+
+const _lexXrpcSubscription = v.object({
 	type: v.literal('subscription'),
 	description: v.string().optional(),
-	parameters: xrpcParametersSchema.optional(),
-	message: xrpcSubscriptionMessageSchema.optional(),
-	errors: v.array(xrpcErrorSchema).optional(),
+	parameters: lexXrpcParameters.optional(),
+	message: lexXrpcSubscriptionMessage.optional(),
+	errors: v.array(lexXrpcError).optional(),
 });
 
-export type XrpcSubscriptionSchema = v.Infer<typeof xrpcSubscriptionSchema>;
+export const lexXrpcSubscription = _lexXrpcSubscription as lexXrpcSubscription.$schema;
+export interface LexXrpcSubscription extends v.Infer<typeof lexXrpcSubscription> {}
+export declare namespace lexXrpcSubscription {
+	export {};
+
+	type $schematype = typeof _lexXrpcSubscription;
+	export interface $schema extends $schematype {}
+}
+
+const LITERAL_KEY_RE = /^literal:(.+)$/;
 
-export const recordSchema = v.object({
+const _lexRecord = v.object({
 	type: v.literal('record'),
 	description: v.string().optional(),
-	key: v.string().optional(),
-	record: objectSchema,
+	key: v
+		.union(
+			v.literal('tid'),
+			v.literal('nsid'),
+			v.literal('any'),
+			v.string().assert<`literal:${string}`>((input) => LITERAL_KEY_RE.test(input)),
+		)
+		.optional(() => 'any'),
+	record: lexObject,
 });
 
-export type RecordSchema = v.Infer<typeof objectSchema>;
-
-export const userTypeSchema = v.union(
-	recordSchema,
-	xrpcQuerySchema,
-	xrpcProcedureSchema,
-	xrpcSubscriptionSchema,
-	blobSchema,
-	arraySchema,
-	tokenSchema,
-	objectSchema,
-	booleanSchema,
-	integerSchema,
-	stringSchema,
-	bytesSchema,
-	cidLinkSchema,
-	unknownSchema,
+export const lexRecord = _lexRecord as lexRecord.$schema;
+export interface LexRecord extends v.Infer<typeof lexRecord> {}
+export declare namespace lexRecord {
+	export {};
+
+	type $schematype = typeof _lexRecord;
+	export interface $schema extends $schematype {}
+}
+
+const _lexUserType = v.union(
+	lexRecord,
+	lexXrpcQuery,
+	lexXrpcProcedure,
+	lexXrpcSubscription,
+	lexObject,
+	lexArray,
+	lexToken,
+	lexIpldType,
+	lexBlob,
+	lexPrimitive,
 );
 
-export type UserTypeSchema = v.Infer<typeof userTypeSchema>;
+export const lexUserType = _lexUserType as lexUserType.$schema;
+export type LexUserType = v.Infer<typeof lexUserType>;
+export declare namespace lexUserType {
+	export {};
+
+	type $schematype = typeof _lexUserType;
+	export interface $schema extends $schematype {}
+}
 
 const NSID_RE =
-	/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/;
-const nsidType = v.string().assert((v) => NSID_RE.test(v), `string doesn't match nsid format`);
+	/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/;
 
-export const documentSchema = v
+const _lexiconDoc = v
 	.object({
 		lexicon: v.literal(1),
-		id: nsidType,
-		revision: v.number().optional(),
+		id: v.string().assert((input) => NSID_RE.test(input), `must be valid nsid`),
+		revision: integer.optional(),
 		description: v.string().optional(),
-		defs: v.record(userTypeSchema),
+		// defs: v.record(v.pipe(v.string(), v.regex(/^[a-zA-Z][a-zA-Z0-9_]{0,62}?$/)), lexUserType),
+		defs: v.record(lexUserType),
 	})
-	.chain((doc) => {
-		const defs = doc.defs;
+	.chain((input) => {
+		const { defs } = input;
 
-		for (const id in defs) {
-			const def = defs[id];
-			const type = def.type;
+		for (const key in defs) {
+			const def = defs[key];
 
 			if (
-				id !== 'main' &&
-				(type === 'record' || type === 'query' || type === 'procedure' || type === 'subscription')
+				key !== 'main' &&
+				(def.type === 'record' ||
+					def.type === 'procedure' ||
+					def.type === 'query' ||
+					def.type === 'subscription')
 			) {
-				return v.err({ message: `${type} must be the \`main\` definition`, path: ['defs', id] });
+				return v.err({
+					message: `records, procedures, queries and subscriptions must be the main definition`,
+					path: ['defs', key],
+				});
 			}
 		}
 
-		return v.ok(doc);
+		return v.ok(input);
 	});
 
-export type DocumentSchema = v.Infer<typeof documentSchema>;
+export const lexiconDoc = _lexiconDoc as lexiconDoc.$schema;
+export interface LexiconDoc extends v.Infer<typeof lexiconDoc> {}
+export declare namespace lexiconDoc {
+	export {};
+
+	type $schematype = typeof _lexiconDoc;
+	export interface $schema extends $schematype {}
+}