@prisma-next/psl-parser 0.14.0-dev.4 → 0.14.0-dev.6

package/dist/declarations-D9h_ihD3.mjs

@@ -0,0 +1,820 @@
+//#region src/syntax/red.ts
+var SyntaxNode = class SyntaxNode {
+	green;
+	offset;
+	parent;
+	constructor(green, offset, parent) {
+		this.green = green;
+		this.offset = offset;
+		this.parent = parent;
+	}
+	get kind() {
+		return this.green.kind;
+	}
+	get textLength() {
+		return this.green.textLength;
+	}
+	get firstChild() {
+		return childAt(this, 0);
+	}
+	get lastChild() {
+		const len = this.green.children.length;
+		if (len === 0) return void 0;
+		return childAt(this, len - 1);
+	}
+	get nextSibling() {
+		if (!this.parent) return void 0;
+		const siblings = this.parent.green.children;
+		let offset = this.parent.offset;
+		let found = false;
+		for (const child of siblings) {
+			if (found) return wrapElement(child, offset, this.parent);
+			const childLen = elementTextLength(child);
+			if (child.type === "node" && offset === this.offset && child === this.green) found = true;
+			offset += childLen;
+		}
+	}
+	get prevSibling() {
+		if (!this.parent) return void 0;
+		const siblings = this.parent.green.children;
+		let offset = this.parent.offset;
+		let prev;
+		for (const child of siblings) {
+			if (child.type === "node" && offset === this.offset && child === this.green) {
+				if (!prev) return void 0;
+				return wrapElement(prev.green, prev.offset, this.parent);
+			}
+			prev = {
+				green: child,
+				offset
+			};
+			offset += elementTextLength(child);
+		}
+	}
+	*children() {
+		let offset = this.offset;
+		for (const child of this.green.children) {
+			yield wrapElement(child, offset, this);
+			offset += elementTextLength(child);
+		}
+	}
+	*childNodes() {
+		for (const child of this.children()) if (child instanceof SyntaxNode) yield child;
+	}
+	*ancestors() {
+		let current = this.parent;
+		while (current) {
+			yield current;
+			current = current.parent;
+		}
+	}
+	*descendants() {
+		const stack = [this];
+		for (let el = stack.pop(); el !== void 0; el = stack.pop()) {
+			yield el;
+			if (el instanceof SyntaxNode) {
+				const children = Array.from(el.children());
+				for (let i = children.length - 1; i >= 0; i--) {
+					const child = children[i];
+					if (child !== void 0) stack.push(child);
+				}
+			}
+		}
+	}
+	*tokens() {
+		for (const el of this.descendants()) if (!(el instanceof SyntaxNode)) yield el;
+	}
+};
+function elementTextLength(el) {
+	return el.type === "token" ? el.text.length : el.textLength;
+}
+function wrapElement(green, offset, parent) {
+	if (green.type === "token") return {
+		kind: green.kind,
+		text: green.text,
+		offset
+	};
+	return new SyntaxNode(green, offset, parent);
+}
+function childAt(node, index) {
+	const children = node.green.children;
+	const target = children[index];
+	if (target === void 0) return void 0;
+	let offset = node.offset;
+	for (let i = 0; i < index; i++) {
+		const child = children[i];
+		if (child !== void 0) offset += elementTextLength(child);
+	}
+	return wrapElement(target, offset, node);
+}
+function createSyntaxTree(green) {
+	return new SyntaxNode(green, 0, void 0);
+}
+//#endregion
+//#region src/syntax/ast-helpers.ts
+function findChildToken(node, kind) {
+	for (const child of node.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) return child;
+}
+function findFirstChild(node, cast) {
+	for (const child of node.childNodes()) {
+		const result = cast(child);
+		if (result !== void 0) return result;
+	}
+}
+function* filterChildren(node, cast) {
+	for (const child of node.childNodes()) {
+		const result = cast(child);
+		if (result !== void 0) yield result;
+	}
+}
+/**
+* Raw source text of a CST node, verbatim (quotes and brackets preserved). For
+* the decoded value of a string literal, decode it instead.
+*/
+function printSyntax(node) {
+	let text = "";
+	for (const token of node.tokens()) text += token.text;
+	return text;
+}
+//#endregion
+//#region src/syntax/ast/identifier.ts
+var IdentifierAst = class IdentifierAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return this.token()?.text;
+	}
+	static cast(node) {
+		return node.kind === "Identifier" ? new IdentifierAst(node) : void 0;
+	}
+};
+//#endregion
+//#region src/syntax/ast/qualified-name.ts
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+var QualifiedNameAst = class QualifiedNameAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	#lastSegment() {
+		let last;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) last = segment;
+		return last;
+	}
+	#penultimateSegment() {
+		let last;
+		let penultimate;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			penultimate = last;
+			last = segment;
+		}
+		return penultimate;
+	}
+	#separatorCount(kind) {
+		let count = 0;
+		for (const child of this.syntax.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) count++;
+		return count;
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	dot() {
+		return findChildToken(this.syntax, "Dot");
+	}
+	space() {
+		if (!this.colon()) return void 0;
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	namespace() {
+		if (!this.dot()) return void 0;
+		return this.#penultimateSegment();
+	}
+	identifier() {
+		return this.#lastSegment();
+	}
+	/**
+	* Every identifier segment, in source order. A bare `Vector` yields
+	* `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
+	*/
+	path() {
+		const segments = [];
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
+	}
+	/**
+	* Flags a malformed name with more qualifier segments than allowed (a second
+	* `:`-space or a second `.`-namespace).
+	*/
+	isOverQualified() {
+		return this.#separatorCount("Dot") > 1 || this.#separatorCount("Colon") > 1;
+	}
+	static cast(node) {
+		return node.kind === "QualifiedName" ? new QualifiedNameAst(node) : void 0;
+	}
+};
+//#endregion
+//#region src/syntax/ast/expressions.ts
+var FunctionCallAst = class FunctionCallAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	/** The qualified-name callee, or `undefined` when identifier segments sit directly under the node. */
+	name() {
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	/**
+	* The dotted call path, in source order. A bare `Vector(…)` yields
+	* `['Vector']`; a namespace-qualified `pgvector.Vector(…)` yields
+	* `['pgvector', 'Vector']`. Empty when the call carries no identifier.
+	*/
+	path() {
+		const qualified = this.name();
+		const segments = [];
+		for (const segment of filterChildren(qualified?.syntax ?? this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
+	}
+	lparen() {
+		return findChildToken(this.syntax, "LParen");
+	}
+	rparen() {
+		return findChildToken(this.syntax, "RParen");
+	}
+	*args() {
+		yield* filterChildren(this.syntax, AttributeArgAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "FunctionCall" ? new FunctionCallAst(node) : void 0;
+	}
+};
+var ArrayLiteralAst = class ArrayLiteralAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lbracket() {
+		return findChildToken(this.syntax, "LBracket");
+	}
+	rbracket() {
+		return findChildToken(this.syntax, "RBracket");
+	}
+	*elements() {
+		yield* filterChildren(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "ArrayLiteral" ? new ArrayLiteralAst(node) : void 0;
+	}
+};
+const HEX = /^[0-9a-fA-F]+$/;
+function decodeFixedHex(raw, start, width) {
+	if (start + width > raw.length) return void 0;
+	const hex = raw.slice(start, start + width);
+	if (!HEX.test(hex)) return void 0;
+	return String.fromCharCode(Number.parseInt(hex, 16));
+}
+function decodeStringLiteral(raw) {
+	let out = "";
+	let i = 0;
+	while (i < raw.length) {
+		const ch = raw.charAt(i);
+		if (ch !== "\\" || i + 1 >= raw.length) {
+			out += ch;
+			i++;
+			continue;
+		}
+		const next = raw.charAt(i + 1);
+		switch (next) {
+			case "n":
+				out += "\n";
+				i += 2;
+				continue;
+			case "r":
+				out += "\r";
+				i += 2;
+				continue;
+			case "t":
+				out += "	";
+				i += 2;
+				continue;
+			case "\"":
+				out += "\"";
+				i += 2;
+				continue;
+			case "'":
+				out += "'";
+				i += 2;
+				continue;
+			case "\\":
+				out += "\\";
+				i += 2;
+				continue;
+			case "x": {
+				const decoded = decodeFixedHex(raw, i + 2, 2);
+				if (decoded === void 0) {
+					out += "\\x";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 4;
+				continue;
+			}
+			case "u": {
+				const decoded = decodeFixedHex(raw, i + 2, 4);
+				if (decoded === void 0) {
+					out += "\\u";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 6;
+				continue;
+			}
+			default:
+				out += `\\${next}`;
+				i += 2;
+				continue;
+		}
+	}
+	return out;
+}
+var StringLiteralExprAst = class StringLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "StringLiteral");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		return decodeStringLiteral(tok.text.slice(1, -1));
+	}
+	static cast(node) {
+		return node.kind === "StringLiteralExpr" ? new StringLiteralExprAst(node) : void 0;
+	}
+};
+var NumberLiteralExprAst = class NumberLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "NumberLiteral");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		return Number(tok.text);
+	}
+	static cast(node) {
+		return node.kind === "NumberLiteralExpr" ? new NumberLiteralExprAst(node) : void 0;
+	}
+};
+var BooleanLiteralExprAst = class BooleanLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		if (tok.text === "true") return true;
+		if (tok.text === "false") return false;
+	}
+	static cast(node) {
+		return node.kind === "BooleanLiteralExpr" ? new BooleanLiteralExprAst(node) : void 0;
+	}
+};
+var ObjectLiteralExprAst = class ObjectLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*fields() {
+		yield* filterChildren(this.syntax, ObjectFieldAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "ObjectLiteralExpr" ? new ObjectLiteralExprAst(node) : void 0;
+	}
+};
+var ObjectFieldAst = class ObjectFieldAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	key() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			return IdentifierAst.cast(child);
+		}
+	}
+	/**
+	* The field's logical key name, unquoted. An identifier key (`length:`) yields
+	* its text; a string-literal key (`"length":`) yields the decoded string.
+	* `undefined` when the field carries no key node.
+	*/
+	keyName() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			const identifier = IdentifierAst.cast(child);
+			if (identifier) return identifier.token()?.text;
+			const stringKey = StringLiteralExprAst.cast(child);
+			if (stringKey) return stringKey.value();
+			return;
+		}
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	value() {
+		if (this.colon()) {
+			let pastColon = false;
+			for (const child of this.syntax.children()) {
+				if (!(child instanceof SyntaxNode)) {
+					if (child.kind === "Colon") pastColon = true;
+					continue;
+				}
+				if (pastColon) {
+					const expr = castExpression(child);
+					if (expr) return expr;
+				}
+			}
+			return;
+		}
+		return findFirstChild(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "ObjectField" ? new ObjectFieldAst(node) : void 0;
+	}
+};
+function castExpression(node) {
+	return FunctionCallAst.cast(node) ?? ArrayLiteralAst.cast(node) ?? StringLiteralExprAst.cast(node) ?? NumberLiteralExprAst.cast(node) ?? BooleanLiteralExprAst.cast(node) ?? ObjectLiteralExprAst.cast(node) ?? IdentifierAst.cast(node);
+}
+var AttributeArgAst = class AttributeArgAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	name() {
+		if (!this.colon()) return void 0;
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	value() {
+		if (this.colon()) {
+			let pastColon = false;
+			for (const child of this.syntax.children()) {
+				if (!(child instanceof SyntaxNode)) {
+					if (child.kind === "Colon") pastColon = true;
+					continue;
+				}
+				if (pastColon) {
+					const expr = castExpression(child);
+					if (expr) return expr;
+				}
+			}
+			return;
+		}
+		return findFirstChild(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "AttributeArg" ? new AttributeArgAst(node) : void 0;
+	}
+};
+//#endregion
+//#region src/syntax/ast/attributes.ts
+var AttributeArgListAst = class AttributeArgListAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lparen() {
+		return findChildToken(this.syntax, "LParen");
+	}
+	rparen() {
+		return findChildToken(this.syntax, "RParen");
+	}
+	*args() {
+		yield* filterChildren(this.syntax, AttributeArgAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "AttributeArgList" ? new AttributeArgListAst(node) : void 0;
+	}
+};
+var FieldAttributeAst = class FieldAttributeAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	at() {
+		return findChildToken(this.syntax, "At");
+	}
+	name() {
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	argList() {
+		return findFirstChild(this.syntax, AttributeArgListAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "FieldAttribute" ? new FieldAttributeAst(node) : void 0;
+	}
+};
+var ModelAttributeAst = class ModelAttributeAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	doubleAt() {
+		return findChildToken(this.syntax, "DoubleAt");
+	}
+	name() {
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	argList() {
+		return findFirstChild(this.syntax, AttributeArgListAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "ModelAttribute" ? new ModelAttributeAst(node) : void 0;
+	}
+};
+//#endregion
+//#region src/syntax/ast/type-annotation.ts
+var TypeAnnotationAst = class TypeAnnotationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	/** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
+	name() {
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	/** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
+	argList() {
+		return findFirstChild(this.syntax, AttributeArgListAst.cast);
+	}
+	isConstructor() {
+		return this.argList() !== void 0;
+	}
+	lbracket() {
+		return findChildToken(this.syntax, "LBracket");
+	}
+	rbracket() {
+		return findChildToken(this.syntax, "RBracket");
+	}
+	questionMark() {
+		return findChildToken(this.syntax, "Question");
+	}
+	isList() {
+		return this.lbracket() !== void 0;
+	}
+	isOptional() {
+		return this.questionMark() !== void 0;
+	}
+	static cast(node) {
+		return node.kind === "TypeAnnotation" ? new TypeAnnotationAst(node) : void 0;
+	}
+};
+//#endregion
+//#region src/syntax/ast/declarations.ts
+function castNamespaceMember(node) {
+	return ModelDeclarationAst.cast(node) ?? CompositeTypeDeclarationAst.cast(node) ?? GenericBlockDeclarationAst.cast(node);
+}
+var DocumentAst = class DocumentAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	*declarations() {
+		yield* filterChildren(this.syntax, (node) => castNamespaceMember(node) ?? TypesBlockAst.cast(node) ?? NamespaceDeclarationAst.cast(node));
+	}
+	static cast(node) {
+		return node.kind === "Document" ? new DocumentAst(node) : void 0;
+	}
+};
+var ModelDeclarationAst = class ModelDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	keyword() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*fields() {
+		yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
+	}
+	*attributes() {
+		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "ModelDeclaration" ? new ModelDeclarationAst(node) : void 0;
+	}
+};
+var CompositeTypeDeclarationAst = class CompositeTypeDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	keyword() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*fields() {
+		yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
+	}
+	*attributes() {
+		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "CompositeTypeDeclaration" ? new CompositeTypeDeclarationAst(node) : void 0;
+	}
+};
+var NamespaceDeclarationAst = class NamespaceDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	keyword() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*declarations() {
+		yield* filterChildren(this.syntax, castNamespaceMember);
+	}
+	static cast(node) {
+		return node.kind === "Namespace" ? new NamespaceDeclarationAst(node) : void 0;
+	}
+};
+var TypesBlockAst = class TypesBlockAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	keyword() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*declarations() {
+		yield* filterChildren(this.syntax, NamedTypeDeclarationAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "TypesBlock" ? new TypesBlockAst(node) : void 0;
+	}
+};
+var GenericBlockDeclarationAst = class GenericBlockDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	keyword() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*entries() {
+		yield* filterChildren(this.syntax, KeyValuePairAst.cast);
+	}
+	*attributes() {
+		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "GenericBlockDeclaration" ? new GenericBlockDeclarationAst(node) : void 0;
+	}
+};
+var KeyValuePairAst = class KeyValuePairAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	key() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	equals() {
+		return findChildToken(this.syntax, "Equals");
+	}
+	value() {
+		let pastEquals = false;
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Equals") pastEquals = true;
+				continue;
+			}
+			if (pastEquals) {
+				const expr = castExpression(child);
+				if (expr) return expr;
+			}
+		}
+	}
+	static cast(node) {
+		return node.kind === "KeyValuePair" ? new KeyValuePairAst(node) : void 0;
+	}
+};
+var FieldDeclarationAst = class FieldDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	typeAnnotation() {
+		return findFirstChild(this.syntax, TypeAnnotationAst.cast);
+	}
+	*attributes() {
+		yield* filterChildren(this.syntax, FieldAttributeAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "FieldDeclaration" ? new FieldDeclarationAst(node) : void 0;
+	}
+};
+var NamedTypeDeclarationAst = class NamedTypeDeclarationAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	name() {
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	equals() {
+		return findChildToken(this.syntax, "Equals");
+	}
+	typeAnnotation() {
+		return findFirstChild(this.syntax, TypeAnnotationAst.cast);
+	}
+	*attributes() {
+		yield* filterChildren(this.syntax, FieldAttributeAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "NamedTypeDeclaration" ? new NamedTypeDeclarationAst(node) : void 0;
+	}
+};
+//#endregion
+export { createSyntaxTree as A, QualifiedNameAst as C, findFirstChild as D, findChildToken as E, printSyntax as O, castExpression as S, filterChildren as T, FunctionCallAst as _, KeyValuePairAst as a, ObjectLiteralExprAst as b, NamespaceDeclarationAst as c, AttributeArgListAst as d, FieldAttributeAst as f, BooleanLiteralExprAst as g, AttributeArgAst as h, GenericBlockDeclarationAst as i, SyntaxNode as k, TypesBlockAst as l, ArrayLiteralAst as m, DocumentAst as n, ModelDeclarationAst as o, ModelAttributeAst as p, FieldDeclarationAst as r, NamedTypeDeclarationAst as s, CompositeTypeDeclarationAst as t, TypeAnnotationAst as u, NumberLiteralExprAst as v, IdentifierAst as w, StringLiteralExprAst as x, ObjectFieldAst as y };
+
+//# sourceMappingURL=declarations-D9h_ihD3.mjs.map