@prisma/orm-target-mysql 0.0.0-stage → 8.0.0-rc.21-dev.23

package/dist/pack-YVG-iBMQ.d.mts

@@ -0,0 +1,1073 @@
+import { t as CodecTypes } from "./codec-types-Bd7DL1Mr-CZWNfnp9.mjs";
+import { DataTypeId, DataTypeValue } from "@prisma/orm-framework/components/codec";
+import "@prisma/orm-framework/components/control";
+import { AuthoringTypeAliasDescriptor, AuthoringTypeChoiceDescriptor, AuthoringTypeConstructorDescriptor, TaggedLiteralCanonicalization } from "@prisma/orm-framework/components/authoring";
+import { SignatureArgumentOutput, SignatureOptionalArgument } from "@prisma/orm-framework/components/components";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { PslSpan } from "@prisma/orm-framework/components/psl-ast";
+import "@prisma/orm-framework/utils/types";
+//#region ../../../3-targets/mysql/1-target/dist/pack.d.mts
+//#region ../../../1-framework/2-authoring/psl-parser/dist/tokenizer-i8RaVWVa.d.mts
+//#region src/tokenizer.d.ts
+type TokenKind = 'Ident' | 'StringLiteral' | 'NumberLiteral' | 'At' | 'DoubleAt' | 'LBrace' | 'RBrace' | 'LParen' | 'RParen' | 'LBracket' | 'RBracket' | 'Equals' | 'Question' | 'Dot' | 'Comma' | 'Colon' | 'Plus' | 'Whitespace' | 'Newline' | 'Comment' | 'Invalid' | 'Eof';
+interface Token {
+  readonly kind: TokenKind;
+  readonly text: string;
+}
+//#endregion
+//#region ../../../1-framework/2-authoring/psl-parser/dist/parse-djL5wker.d.mts
+//#region src/syntax/syntax-kind.d.ts
+type SyntaxKind = 'Document' | 'ModelDeclaration' | 'CompositeTypeDeclaration' | 'Namespace' | 'TypesBlock' | 'GenericBlockDeclaration' | 'MixinDeclaration' | 'MixinInclusion' | 'FieldDeclaration' | 'NamedTypeDeclaration' | 'KeyValuePair' | 'FieldAttribute' | 'ModelAttribute' | 'AttributeArgList' | 'AttributeArg' | 'TypeAnnotation' | 'Identifier' | 'QualifiedName' | 'FunctionCall' | 'PathExpr' | 'ArrayLiteral' | 'StringLiteralExpr' | 'TaggedLiteral' | 'NumberLiteralExpr' | 'BooleanLiteralExpr' | 'ObjectLiteralExpr' | 'ObjectField';
+//#endregion
+//#region src/syntax/green.d.ts
+interface GreenToken {
+  readonly type: 'token';
+  readonly kind: TokenKind;
+  readonly text: string;
+}
+interface GreenNode {
+  readonly type: 'node';
+  readonly kind: SyntaxKind;
+  readonly children: ReadonlyArray<GreenElement>;
+  readonly textLength: number;
+}
+type GreenElement = GreenNode | GreenToken;
+//#endregion
+//#region src/syntax/red.d.ts
+/**
+ * A token in the red tree. Unlike the green-layer {@link Token} (kind + text
+ * only), a red token also carries its absolute `offset` within the source and a
+ * link back to its `parent` {@link SyntaxNode}, so a cursor anchored on a token
+ * can walk outward (parent, previous/next token, siblings) without re-scanning
+ * from the document root.
+ */
+declare class SyntaxToken implements Token {
+  readonly green: GreenToken;
+  readonly kind: TokenKind;
+  readonly text: string;
+  readonly offset: number;
+  readonly parent: SyntaxNode;
+  /** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+  readonly index: number;
+  constructor(green: GreenToken, offset: number, parent: SyntaxNode, index: number);
+  get textLength(): number;
+  get endOffset(): number;
+  /** Whether `offset` falls within this token, inclusive of both ends. */
+  isInside(offset: number): boolean;
+  isOutside(offset: number): boolean;
+  /** The sibling element immediately after this token within its parent. */
+  get nextSiblingOrToken(): SyntaxElement | undefined;
+  /** The sibling element immediately before this token within its parent. */
+  get prevSiblingOrToken(): SyntaxElement | undefined;
+  /** The next token in document order, crossing node boundaries. */
+  get nextToken(): SyntaxToken | undefined;
+  /** The previous token in document order, crossing node boundaries. */
+  get prevToken(): SyntaxToken | undefined;
+}
+type SyntaxElement = SyntaxNode | SyntaxToken;
+declare class TokenAtOffset {
+  #private;
+  private constructor();
+  static none(): TokenAtOffset;
+  static single(token: SyntaxToken): TokenAtOffset;
+  static between(left: SyntaxToken, right: SyntaxToken): TokenAtOffset;
+  get isEmpty(): boolean;
+  get isBetween(): boolean;
+  leftBiased(): SyntaxToken | undefined;
+  rightBiased(): SyntaxToken | undefined;
+}
+declare class SyntaxNode {
+  #private;
+  readonly green: GreenNode;
+  readonly offset: number;
+  readonly parent: SyntaxNode | undefined;
+  /** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+  readonly index: number;
+  constructor(green: GreenNode, offset: number, parent: SyntaxNode | undefined, index: number);
+  childAt(index: number): SyntaxElement | undefined;
+  get kind(): SyntaxKind;
+  get textLength(): number;
+  get endOffset(): number;
+  /** Whether `offset` falls within this node, inclusive of both ends. */
+  isInside(offset: number): boolean;
+  isOutside(offset: number): boolean;
+  get firstChild(): SyntaxElement | undefined;
+  get lastChild(): SyntaxElement | undefined;
+  get nextSibling(): SyntaxElement | undefined;
+  get prevSibling(): SyntaxElement | undefined;
+  /** The sibling element immediately after this node within its parent. */
+  get nextSiblingOrToken(): SyntaxElement | undefined;
+  /** The sibling element immediately before this node within its parent. */
+  get prevSiblingOrToken(): SyntaxElement | undefined;
+  /** The first token in this subtree (depth-first), or `undefined` if empty. */
+  get firstToken(): SyntaxToken | undefined;
+  /** The last token in this subtree (depth-first), or `undefined` if empty. */
+  get lastToken(): SyntaxToken | undefined;
+  children(): Iterable<SyntaxElement>;
+  childNodes(): Iterable<SyntaxNode>;
+  root(): SyntaxNode;
+  ancestors(): Iterable<SyntaxNode>;
+  /** The nearest match, testing this node itself before walking its ancestors. */
+  findAncestor<T>(cast: (node: SyntaxNode) => T | undefined): T | undefined;
+  descendants(): Iterable<SyntaxElement>;
+  tokens(): Iterable<SyntaxToken>;
+  /**
+   * The token(s) at `offset`. The between-two-tokens case (offset exactly on a
+   * token seam) is represented explicitly so callers can left/right bias.
+   */
+  tokenAtOffset(offset: number): TokenAtOffset;
+  /**
+   * The smallest element fully containing the range `[start, end]`. At a seam
+   * (and for empty ranges) the left-hand element is preferred, matching
+   * {@link containsOffset}'s inclusive span.
+   */
+  coveringElement(start: number, end: number): SyntaxElement;
+}
+//#endregion
+//#region src/source-file.d.ts
+interface Position {
+  readonly line: number;
+  readonly character: number;
+}
+interface Range {
+  readonly start: Position;
+  readonly end: Position;
+}
+declare class SourceFile {
+  #private;
+  constructor(filename: string, text: string);
+  get filename(): string;
+  get text(): string;
+  get length(): number;
+  get lineCount(): number;
+  lineStartOffsets(): readonly number[];
+  lineStartOffset(line: number): number;
+  lineEndOffset(line: number): number;
+  positionAt(offset: number): Position;
+  offsetAt(position: Position): number;
+  offsetToPslPosition(offset: number): PslSpan['start'];
+  rangeToPslSpan(range: Range): PslSpan;
+  pslSpanToRange(span: PslSpan): Range;
+}
+declare class PslSources {
+  #private;
+  constructor(entries: Iterable<readonly [SyntaxNode, SourceFile]>);
+  /**
+   * A new registry uniting this one with `others` — e.g. the per-document
+   * `PslSources` registries `parse()` returns for each member of a
+   * multi-file schema, united into the one registry `buildSymbolTable` and
+   * the interpreters expect.
+   */
+  merge(...others: readonly PslSources[]): PslSources;
+  sourceFileNamed(filename: string): SourceFile;
+  sourceFileFor(node: SyntaxNode): SourceFile;
+}
+//#endregion
+//#region src/diagnostic.d.ts
+interface PslDiagnostic {
+  readonly filename: string;
+  readonly code: string;
+  readonly message: string;
+  readonly range: Range;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+//#endregion
+//#region src/syntax/ast-helpers.d.ts
+interface AstNode {
+  readonly syntax: SyntaxNode;
+}
+interface BracedBlock extends AstNode {
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+}
+interface HasDocComment {
+  docComment(): string | undefined;
+}
+//#endregion
+//#region src/syntax/ast/identifier.d.ts
+declare class IdentifierAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  name(): string | undefined;
+  static cast(node: SyntaxNode): IdentifierAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/qualified-name.d.ts
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+declare class QualifiedNameAst implements AstNode {
+  #private;
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  colon(): SyntaxToken | undefined;
+  dot(): SyntaxToken | undefined;
+  space(): IdentifierAst | undefined;
+  namespace(): IdentifierAst | undefined;
+  identifier(): IdentifierAst | undefined;
+  segments(): Iterable<IdentifierAst>;
+  /**
+   * Every identifier segment, in source order. A bare `Vector` yields
+   * `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
+   */
+  path(): readonly string[];
+  /** True iff this is a single unqualified identifier whose text equals `name`. */
+  isSimpleName(name: string): boolean;
+  /**
+   * Flags a malformed name with more qualifier segments than allowed (a second
+   * `:`-space or a second `.`-namespace).
+   */
+  isOverQualified(): boolean;
+  static cast(node: SyntaxNode): QualifiedNameAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/expressions.d.ts
+declare class FunctionCallAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  /** The callee when it is a bare name, such as `now` in `now()`; `undefined` when the callee is dotted. */
+  name(): QualifiedNameAst | undefined;
+  /**
+   * The callee's segments, in source order. A bare `Vector(…)` yields
+   * `['Vector']`; `pgvector.Vector(…)` yields `['pgvector', 'Vector']`;
+   * `address.geo.lat(…)` yields `['address', 'geo', 'lat']`. Empty when the
+   * call carries no identifier.
+   */
+  path(): readonly string[];
+  /** The callee when it is dotted, such as `address.city` in `address.city(sort: Asc)`; `undefined` for a bare callee. */
+  memberPath(): PathExprAst | undefined;
+  lparen(): SyntaxToken | undefined;
+  rparen(): SyntaxToken | undefined;
+  args(): Iterable<AttributeArgAst>;
+  static cast(node: SyntaxNode): FunctionCallAst | undefined;
+}
+/** A dotted member path in expression position, such as `address.city` in `@@index([address.city])`. */
+declare class PathExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  segments(): Iterable<IdentifierAst>;
+  /**
+   * The segment names, in source order: `['address', 'city']` for `address.city`. A path that ends
+   * in a `.` with no name after it, as in `address.`, ends in an empty name.
+   */
+  path(): readonly string[];
+  static cast(node: SyntaxNode): PathExprAst | undefined;
+}
+declare class ArrayLiteralAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  lbracket(): SyntaxToken | undefined;
+  rbracket(): SyntaxToken | undefined;
+  elements(): Iterable<ExpressionAst>;
+  static cast(node: SyntaxNode): ArrayLiteralAst | undefined;
+}
+type StringLiteralQuote = '"' | "'" | '`';
+declare class StringLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  quote(): StringLiteralQuote | undefined;
+  /**
+   * The decoded string. A `"` or `'` string resolves the usual escapes; a backtick string resolves
+   * only `` \` `` and `\\`, keeping every other backslash sequence as written.
+   */
+  value(): string | undefined;
+  static cast(node: SyntaxNode): StringLiteralExprAst | undefined;
+}
+/** `` tag`body` ``, `tag"body"`, or `tag'body'`: a qualified-name tag followed by a string literal. */
+declare class TaggedLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  tag(): QualifiedNameAst | undefined;
+  /** The tag without trivia, e.g. `postgis.geometry`. */
+  tagName(): string;
+  literal(): StringLiteralExprAst | undefined;
+  canonicalization(): TaggedLiteralCanonicalization;
+  /** The canonical text shared with the TypeScript `sql` tag, or `undefined` when canonicalization fails. */
+  text(): string | undefined;
+  static cast(node: SyntaxNode): TaggedLiteralExprAst | undefined;
+}
+declare class NumberLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  value(): number | undefined;
+  static cast(node: SyntaxNode): NumberLiteralExprAst | undefined;
+}
+declare class BooleanLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  value(): boolean | undefined;
+  static cast(node: SyntaxNode): BooleanLiteralExprAst | undefined;
+}
+declare class ObjectLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  fields(): Iterable<ObjectFieldAst>;
+  static cast(node: SyntaxNode): ObjectLiteralExprAst | undefined;
+}
+declare class ObjectFieldAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  key(): IdentifierAst | undefined;
+  /**
+   * 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(): string | undefined;
+  colon(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  static cast(node: SyntaxNode): ObjectFieldAst | undefined;
+}
+type ExpressionAst = FunctionCallAst | ArrayLiteralAst | StringLiteralExprAst | TaggedLiteralExprAst | NumberLiteralExprAst | BooleanLiteralExprAst | ObjectLiteralExprAst | PathExprAst | IdentifierAst;
+declare class AttributeArgAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  colon(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  static cast(node: SyntaxNode): AttributeArgAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/attributes.d.ts
+declare class AttributeArgListAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  lparen(): SyntaxToken | undefined;
+  rparen(): SyntaxToken | undefined;
+  args(): Iterable<AttributeArgAst>;
+  static cast(node: SyntaxNode): AttributeArgListAst | undefined;
+}
+declare class FieldAttributeAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  at(): SyntaxToken | undefined;
+  name(): QualifiedNameAst | undefined;
+  argList(): AttributeArgListAst | undefined;
+  static cast(node: SyntaxNode): FieldAttributeAst | undefined;
+}
+declare class ModelAttributeAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  doubleAt(): SyntaxToken | undefined;
+  name(): QualifiedNameAst | undefined;
+  argList(): AttributeArgListAst | undefined;
+  static cast(node: SyntaxNode): ModelAttributeAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/type-annotation.d.ts
+declare class TypeAnnotationAst implements AstNode {
+  #private;
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  /** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
+  name(): QualifiedNameAst | undefined;
+  /** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
+  argList(): AttributeArgListAst | undefined;
+  isConstructor(): boolean;
+  lbracket(): SyntaxToken | undefined;
+  rbracket(): SyntaxToken | undefined;
+  questionMark(): SyntaxToken | undefined;
+  isList(): boolean;
+  /**
+   * The list/field axis: a `?` after `]` (list nullable) or, when this is not a
+   * list, the sole field-level `?`. A `?` before `[` is the element axis and
+   * does not count here.
+   */
+  isOptional(): boolean;
+  /** The element axis: a `?` positioned before `[`, meaningful only for lists. */
+  isElementOptional(): boolean;
+  static cast(node: SyntaxNode): TypeAnnotationAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/declarations.d.ts
+/**
+ * What may appear inside a `namespace` block: models, composite types,
+ * extension (block) declarations, and mixin declarations. `types {}` blocks
+ * and nested `namespace` blocks are document-only, so they are not namespace
+ * members.
+ */
+type NamespaceMemberAst = ModelDeclarationAst | CompositeTypeDeclarationAst | GenericBlockDeclarationAst | MixinDeclarationAst;
+type BlockMemberAst = FieldDeclarationAst | ModelAttributeAst | MixinInclusionAst;
+type GenericBlockMemberAst = KeyValuePairAst | ModelAttributeAst | MixinInclusionAst;
+declare class ModelDeclarationAst implements BracedBlock, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  fields(): Iterable<FieldDeclarationAst>;
+  attributes(): Iterable<ModelAttributeAst>;
+  inclusions(): Iterable<MixinInclusionAst>;
+  members(): Iterable<BlockMemberAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): ModelDeclarationAst | undefined;
+}
+declare class CompositeTypeDeclarationAst implements BracedBlock, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  fields(): Iterable<FieldDeclarationAst>;
+  attributes(): Iterable<ModelAttributeAst>;
+  inclusions(): Iterable<MixinInclusionAst>;
+  members(): Iterable<BlockMemberAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): CompositeTypeDeclarationAst | undefined;
+}
+declare class NamespaceDeclarationAst implements BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  declarations(): Iterable<NamespaceMemberAst>;
+  static cast(node: SyntaxNode): NamespaceDeclarationAst | undefined;
+}
+declare class GenericBlockDeclarationAst implements BracedBlock, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  entries(): Iterable<KeyValuePairAst>;
+  /** Field lines of a `view` body. Empty for every other generic block. */
+  fields(): Iterable<FieldDeclarationAst>;
+  attributes(): Iterable<ModelAttributeAst>;
+  inclusions(): Iterable<MixinInclusionAst>;
+  members(): Iterable<GenericBlockMemberAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): GenericBlockDeclarationAst | undefined;
+}
+declare class MixinDeclarationAst implements BracedBlock, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  mixinKeyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  fields(): Iterable<FieldDeclarationAst>;
+  entries(): Iterable<KeyValuePairAst>;
+  attributes(): Iterable<ModelAttributeAst>;
+  /** A mixin cannot include a mixin, but the parser still reads an inclusion written in a mixin body, so that it can be reported as an error at that inclusion. */
+  inclusions(): Iterable<MixinInclusionAst>;
+  members(): Iterable<BlockMemberAst | GenericBlockMemberAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): MixinDeclarationAst | undefined;
+}
+declare class MixinInclusionAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  plus(): SyntaxToken | undefined;
+  name(): QualifiedNameAst | undefined;
+  static cast(node: SyntaxNode): MixinInclusionAst | undefined;
+}
+declare class KeyValuePairAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  key(): IdentifierAst | undefined;
+  equals(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  /** `@` attributes after the key or value, as in `USER @map("user")`. */
+  attributes(): Iterable<FieldAttributeAst>;
+  static cast(node: SyntaxNode): KeyValuePairAst | undefined;
+}
+declare class FieldDeclarationAst implements AstNode, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  typeAnnotation(): TypeAnnotationAst | undefined;
+  attributes(): Iterable<FieldAttributeAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): FieldDeclarationAst | undefined;
+}
+declare class NamedTypeDeclarationAst implements AstNode, HasDocComment {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  equals(): SyntaxToken | undefined;
+  typeAnnotation(): TypeAnnotationAst | undefined;
+  attributes(): Iterable<FieldAttributeAst>;
+  docComment(): string | undefined;
+  static cast(node: SyntaxNode): NamedTypeDeclarationAst | undefined;
+}
+//#endregion
+//#region ../../../1-framework/2-authoring/psl-parser/dist/binder-CMy3WM5A.d.mts
+//#region src/resolve.d.ts
+interface ResolvedAttributeArg {
+  readonly kind: 'positional' | 'named';
+  readonly name?: string;
+  readonly value: string;
+  readonly expression?: ExpressionAst;
+  readonly span: PslSpan;
+  /** The argument as the schema writes it; absent for an argument a reader builds. */
+  readonly node?: AttributeArgAst;
+}
+interface ResolvedAttribute<TNode extends FieldAttributeAst | ModelAttributeAst = FieldAttributeAst | ModelAttributeAst> {
+  readonly name: string;
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+  readonly node: TNode;
+}
+interface ResolvedTypeConstructorCall {
+  readonly path: readonly string[];
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+//#endregion
+//#region src/symbol-table.d.ts
+interface SymbolTable {
+  readonly defaultNamespace: NamespaceSymbol;
+  readonly namespaces: Record<string, NamespaceSymbol>;
+  readonly namedTypes: Record<string, NamedTypeSymbol>;
+}
+interface NamespaceDeclaration {
+  readonly node: NamespaceDeclarationAst;
+  readonly span: PslSpan;
+}
+interface NamespaceSymbol {
+  readonly kind: 'namespace';
+  readonly id: string;
+  readonly name: string;
+  readonly declarations: readonly NamespaceDeclaration[];
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+  readonly mixins: Record<string, MixinSymbol>;
+}
+interface ModelSymbol {
+  readonly kind: 'model';
+  readonly name: string;
+  readonly node: ModelDeclarationAst;
+  readonly span: PslSpan;
+  fields: Record<string, FieldSymbol>;
+  attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface CompositeTypeSymbol {
+  readonly kind: 'compositeType';
+  readonly name: string;
+  readonly node: CompositeTypeDeclarationAst;
+  readonly span: PslSpan;
+  fields: Record<string, FieldSymbol>;
+  attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface BlockSymbol {
+  readonly kind: 'block';
+  readonly name: string;
+  readonly keyword: string;
+  readonly node: GenericBlockDeclarationAst;
+  readonly span: PslSpan;
+  entries: readonly KeyValuePairAst[];
+  attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface MixinSymbol {
+  readonly kind: 'mixin';
+  readonly name: string;
+  readonly keyword: string;
+  readonly node: MixinDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly entries: readonly KeyValuePairAst[];
+  readonly attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface ResolvedNamedTypeBinding {
+  readonly baseType?: string;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly isConstructor: boolean;
+  readonly attributes: readonly ResolvedAttribute<FieldAttributeAst>[];
+}
+/**
+ * A `types {}` binding, collected without classification: whether the binding
+ * refines a target scalar is pronounced by the interpreter
+ * (`resolveNamedTypeDeclarations`), not by the family-blind symbol table.
+ */
+interface NamedTypeSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'namedType';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+interface FieldSymbol {
+  readonly kind: 'field';
+  readonly name: string;
+  readonly node: FieldDeclarationAst;
+  readonly span: PslSpan;
+  readonly typeName: string;
+  readonly typeNamespaceId?: string;
+  readonly typeContractSpaceId?: string;
+  readonly optional: boolean;
+  readonly list: boolean;
+  /** Element-nullability axis (`Foo?[]`); meaningful only when {@link list}. */
+  readonly elementOptional: boolean;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly attributes: readonly ResolvedAttribute<FieldAttributeAst>[];
+  /** Prevents cascading unsupported-type diagnostics after invalid qualification. */
+  readonly malformedType?: boolean;
+}
+//#endregion
+//#region src/entity-reference.d.ts
+type EntitySelector = {
+  readonly kind: 'model';
+} | {
+  readonly kind: 'compositeType';
+} | {
+  readonly kind: 'namedType';
+} | {
+  readonly kind: 'block';
+  readonly keyword: string;
+};
+type EntityDeclaration = ModelSymbol | CompositeTypeSymbol | NamedTypeSymbol | BlockSymbol;
+type NamespaceOfDeclaration<D extends EntityDeclaration> = D extends NamedTypeSymbol ? undefined : NamespaceSymbol;
+interface ResolvedEntityReference<D extends EntityDeclaration = EntityDeclaration> {
+  readonly declaration: D;
+  readonly namespace: NamespaceOfDeclaration<D>;
+}
+//#endregion
+//#region src/attribute-spec/types.d.ts
+type AttributeLevel = 'field' | 'model' | 'block';
+interface AttributeCtx {
+  readonly sources: PslSources;
+  readonly symbols: SymbolTable;
+  readonly binder: Binder;
+}
+interface ModelAttributeCtx extends AttributeCtx {
+  readonly selfModel: ModelSymbol;
+}
+interface BlockAttributeCtx extends AttributeCtx {
+  readonly selfBlock: BlockSymbol;
+}
+interface FieldAttributeCtx extends ModelAttributeCtx {
+  readonly field: FieldSymbol;
+}
+interface ArgTypeOutput<T, Ctx extends AttributeCtx> extends SignatureArgumentOutput<T> {
+  readonly label: string;
+  /** True when the argument has this type's shape, so that its diagnostics are about the argument. `oneOf` returns the result of the one alternative that claims the argument. */
+  readonly claims?: (arg: ExpressionAst) => boolean;
+  readonly parse: (arg: ExpressionAst, ctx: Ctx) => Result<T, readonly PslDiagnostic[]>;
+}
+interface BoolArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<boolean, Ctx> {
+  readonly kind: 'bool';
+}
+interface EntityRefArgType<D extends EntityDeclaration = EntityDeclaration, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<ResolvedEntityReference<D>, Ctx> {
+  readonly kind: 'entityRef';
+  readonly expected: EntitySelector;
+}
+interface FieldRefArgType<Ctx extends ModelAttributeCtx = ModelAttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'fieldRef';
+}
+interface ReferencedFieldRefArgType<Ctx extends FieldAttributeCtx = FieldAttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'referencedFieldRef';
+}
+interface FuncCallSig<Ctx extends AttributeCtx = AttributeCtx> {
+  readonly documentation: string;
+  readonly positional?: readonly PositionalParam<unknown, Ctx>[];
+  readonly named?: Readonly<Record<string, Param<unknown, Ctx>>>;
+}
+interface TypedFuncCall {
+  readonly fn: string;
+  readonly span: PslSpan;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+interface FuncCallArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx, Signature extends FuncCallSig<never> = FuncCallSig<Ctx>> extends ArgTypeOutput<TypedFuncCall, Ctx> {
+  readonly kind: 'funcCall';
+  readonly name: Name;
+  readonly signature: Signature;
+  readonly claims: (arg: ExpressionAst) => boolean;
+}
+interface FixedIdentifierArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Name, Ctx> {
+  readonly kind: 'identifier';
+  readonly name: Name;
+  readonly documentation: string;
+}
+interface UnrestrictedIdentifierArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'identifier';
+  readonly name: undefined;
+}
+type IdentifierArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx> = FixedIdentifierArgType<Name, Ctx> | UnrestrictedIdentifierArgType<Ctx>;
+interface IntArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<number, Ctx> {
+  readonly kind: 'int';
+  readonly min?: number;
+  readonly max?: number;
+}
+interface JsonArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Record<string, unknown>, Ctx> {
+  readonly kind: 'json';
+}
+interface NullArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<null, Ctx> {
+  readonly kind: 'null';
+}
+interface ListArgType<T = unknown, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T[], Ctx> {
+  readonly kind: 'list';
+  readonly of: ArgType<T, Ctx>;
+  readonly allowEmpty: boolean;
+  readonly unique: boolean;
+}
+interface UnrestrictedNumArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<number, Ctx> {
+  readonly kind: 'num';
+  readonly value: undefined;
+}
+interface FixedNumArgType<T extends number = number, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'num';
+  readonly value: T;
+}
+interface NumLiteral {
+  readonly text: string;
+}
+interface NumLiteralArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<NumLiteral, Ctx> {
+  readonly kind: 'num';
+  readonly value: undefined;
+}
+interface OneOfMetadata {
+  readonly kind: 'oneOf';
+  /** Whether the label reads as a union: several labels joined by ` | `. False for a union that names itself, as `JSON value` does. */
+  readonly labelIsUnion: boolean;
+  readonly alternatives: readonly [AnyArgType, ...AnyArgType[]];
+}
+interface RecordArgType<T = unknown, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Record<string, T>, Ctx> {
+  readonly kind: 'record';
+  readonly of: ArgType<T, Ctx>;
+}
+interface RejectingArgType<T = never, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'rejecting';
+  readonly message: string;
+}
+interface UnrestrictedStrArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'str';
+  readonly value: undefined;
+}
+interface FixedStrArgType<T extends string = string, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'str';
+  readonly value: T;
+}
+/**
+ * A tagged literal argument as parsed: its tag, the canonicalization of its string literal, and its
+ * span. Neither the tag nor the canonicalization has been checked; the consumer checks both.
+ */
+interface ParsedTaggedLiteral {
+  readonly tag: string;
+  readonly canonicalization: TaggedLiteralCanonicalization;
+  readonly span: PslSpan;
+}
+interface TaggedLiteralArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<ParsedTaggedLiteral, Ctx> {
+  readonly kind: 'taggedLiteral';
+  readonly tags: readonly string[];
+  readonly documentation: string;
+}
+/** A value of a data type parsed from an argument, with the argument's span. */
+interface ParsedTypedValue {
+  readonly value: DataTypeValue;
+  readonly span: PslSpan;
+}
+interface DataTypeValueArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<ParsedTypedValue, Ctx> {
+  readonly kind: 'dataTypeValue';
+  readonly dataType: DataTypeId;
+  /** The tags a position of this type admits, for completion. */
+  readonly tags: readonly string[];
+  /** The documentation of this type's authoring entry, or '' when it has none. */
+  readonly documentation: string;
+  /** Written values offered for completion besides the tags, such as the versions a function takes. */
+  readonly suggestions: readonly string[];
+  /** Whether the label reads as a union: several suggestions joined by ` | `. */
+  readonly labelIsUnion: boolean;
+}
+type ArgTypeMetadata<Type> = Type extends object ? Omit<Type, keyof ArgTypeOutput<unknown, never>> : never;
+type ArgType<T, Ctx extends AttributeCtx> = ArgTypeOutput<T, Ctx> & ArgTypeMetadata<ArgTypeVariant<Ctx>>;
+type AnyArgType = ArgType<unknown, AttributeCtx> | ArgType<unknown, ModelAttributeCtx> | ArgType<unknown, FieldAttributeCtx>;
+type ArgTypeVariant<Ctx extends AttributeCtx> = BoolArgType<Ctx> | DataTypeValueArgType<Ctx> | EntityRefArgType<EntityDeclaration, Ctx> | FieldRefArgType<ModelAttributeCtx & Ctx> | FuncCallArgType<string, Ctx> | IdentifierArgType<string, Ctx> | IntArgType<Ctx> | JsonArgType<Ctx> | NullArgType<Ctx> | ListArgType<unknown, Ctx> | FixedNumArgType<number, Ctx> | UnrestrictedNumArgType<Ctx> | NumLiteralArgType<Ctx> | OneOfMetadata | RecordArgType<unknown, Ctx> | ReferencedFieldRefArgType<FieldAttributeCtx & Ctx> | RejectingArgType<never, Ctx> | FixedStrArgType<string, Ctx> | UnrestrictedStrArgType<Ctx> | TaggedLiteralArgType<Ctx>;
+type OptionalArgType<T, Ctx extends AttributeCtx, Type extends object = ArgType<T, Ctx>, HasDefault extends boolean = boolean> = Type & OptionalArgumentMarks<T, HasDefault>;
+/** What `optional(...)` adds to an argument type: the shared optional mark `gen` reads, and its default. */
+interface OptionalArgumentMarks<T, HasDefault extends boolean> extends SignatureOptionalArgument {
+  readonly hasDefault: HasDefault;
+  readonly defaultValue?: T | undefined;
+}
+interface Param<T, Ctx extends AttributeCtx> {
+  readonly type: ArgType<T, Ctx>;
+  readonly documentation: string;
+}
+interface PositionalParam<T, Ctx extends AttributeCtx> extends Param<T, Ctx> {
+  readonly key: string;
+}
+interface AttributeSpec<Out, Ctx extends AttributeCtx> {
+  readonly documentation: string;
+  readonly level: AttributeLevel;
+  readonly name: string;
+  readonly positional: readonly PositionalParam<unknown, Ctx>[];
+  readonly named: Readonly<Record<string, Param<unknown, Ctx>>>;
+  /**
+   * Cross-argument validation after all arguments parse. `attributeNode` is
+   * the attribute's own AST node so refines can span-anchor their
+   * diagnostics at the attribute rather than the enclosing model.
+   */
+  readonly refine?: (parsed: Out, ctx: Ctx, attributeNode: AstNode) => readonly PslDiagnostic[];
+}
+//#endregion
+//#region src/contributed-type-scope.d.ts
+type ContributedTypeDescriptor = AuthoringTypeConstructorDescriptor | AuthoringTypeAliasDescriptor | AuthoringTypeChoiceDescriptor;
+interface ContributedTypeSymbolBase {
+  readonly kind: 'contributedType';
+  readonly name: string;
+  readonly path: readonly string[];
+}
+/** A contributed type choice, with the type constructors its rows name, by name, from the namespace that holds it. */
+interface ContributedTypeChoiceSymbol extends ContributedTypeSymbolBase {
+  readonly descriptor: AuthoringTypeChoiceDescriptor;
+  readonly choiceTypes: ReadonlyMap<string, AuthoringTypeConstructorDescriptor>;
+}
+type ContributedTypeSymbol = (ContributedTypeSymbolBase & {
+  readonly descriptor: Exclude<ContributedTypeDescriptor, AuthoringTypeChoiceDescriptor>;
+}) | ContributedTypeChoiceSymbol;
+interface ContributedNamespaceSymbol {
+  readonly kind: 'contributedNamespace';
+  readonly name: string;
+  readonly path: readonly string[];
+  readonly members: ReadonlyMap<string, ContributedMember>;
+}
+type ContributedMember = ContributedTypeSymbol | ContributedNamespaceSymbol;
+//#endregion
+//#region src/scope.d.ts
+type ScopeResolution = {
+  readonly kind: 'model';
+  readonly symbol: ModelSymbol;
+  readonly namespace: NamespaceSymbol;
+} | {
+  readonly kind: 'compositeType';
+  readonly symbol: CompositeTypeSymbol;
+  readonly namespace: NamespaceSymbol;
+} | {
+  readonly kind: 'namedType';
+  readonly symbol: NamedTypeSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'block';
+  readonly symbol: BlockSymbol;
+  readonly namespace: NamespaceSymbol;
+} | {
+  readonly kind: 'mixin';
+  readonly symbol: MixinSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'namespace';
+  readonly symbol: NamespaceSymbol;
+} | {
+  readonly kind: 'contributedNamespace';
+  readonly symbol: ContributedNamespaceSymbol;
+} | {
+  readonly kind: 'contributedType';
+  readonly symbol: ContributedTypeSymbol;
+};
+declare abstract class Scope {
+  protected readonly parent: Scope | undefined;
+  constructor(parent: Scope | undefined);
+  abstract lookup(name: string): ScopeResolution | undefined;
+  protected abstract ownNames(): Iterable<string>;
+  entries(): Iterable<readonly [string, ScopeResolution]>;
+}
+type BoundSpec = AttributeSpec<never, ModelAttributeCtx> | AttributeSpec<never, FieldAttributeCtx> | AttributeSpec<never, BlockAttributeCtx>;
+interface AttributeSymbol {
+  readonly kind: 'attribute';
+  readonly name: string;
+  readonly level: 'model' | 'field' | 'block';
+  readonly spec: BoundSpec;
+}
+interface ParameterSymbol {
+  readonly kind: 'parameter';
+  readonly name: string;
+  readonly param: Param<unknown, never>;
+}
+interface FunctionSymbol {
+  readonly kind: 'function';
+  readonly name: string;
+  readonly signature: FuncCallSig<never>;
+}
+interface ConstantSymbol {
+  readonly kind: 'constant';
+  readonly name: string;
+  readonly documentation: string;
+}
+type PslSymbol = ModelSymbol | CompositeTypeSymbol | NamedTypeSymbol | BlockSymbol | NamespaceSymbol | MixinSymbol | FieldSymbol;
+type Resolution = ScopeResolution | {
+  readonly kind: 'field';
+  readonly symbol: FieldSymbol;
+} | {
+  readonly kind: 'attribute';
+  readonly symbol: AttributeSymbol;
+} | {
+  readonly kind: 'parameter';
+  readonly symbol: ParameterSymbol;
+} | {
+  readonly kind: 'function';
+  readonly symbol: FunctionSymbol;
+} | {
+  readonly kind: 'constant';
+  readonly symbol: ConstantSymbol;
+} | {
+  readonly kind: 'crossSpace';
+} | {
+  readonly kind: 'unresolved';
+  readonly name: string;
+};
+interface Binder {
+  declaredSymbol(node: SyntaxNode): PslSymbol | undefined;
+  symbolForNode(node: SyntaxNode): Resolution | undefined;
+  scopeAt(node: SyntaxNode): Scope;
+}
+//#endregion
+//#region src/core/descriptor-meta.d.ts
+declare const mysqlTargetDescriptorMetaBase: {
+  readonly defaultNamespaceId: "__unbound__";
+  readonly supportsNamespaces: false;
+  readonly displayName: "MySQL";
+  readonly authoring: {
+    readonly type: {
+      readonly sql: {
+        readonly String: {
+          readonly kind: "typeConstructor";
+          readonly documentation: "Variable-length text with a required maximum character length.";
+          readonly args: readonly [{
+            readonly kind: "value";
+            readonly dataType: "mysql/int";
+            readonly name: "length";
+          }];
+          readonly output: {
+            readonly codecId: "sql/varchar@1";
+            readonly typeParams: {
+              readonly length: {
+                readonly kind: "arg";
+                readonly index: 0;
+              };
+            };
+          };
+        };
+        readonly Char: {
+          readonly kind: "typeConstructor";
+          readonly documentation: "Fixed-length text with a required character length.";
+          readonly args: readonly [{
+            readonly kind: "value";
+            readonly dataType: "mysql/int";
+            readonly name: "length";
+          }];
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly typeParams: {
+              readonly length: {
+                readonly kind: "arg";
+                readonly index: 0;
+              };
+            };
+          };
+        };
+      };
+      readonly String: {
+        readonly kind: "typeConstructor";
+        readonly documentation: "Text of at most 191 characters, stored as MySQL varchar(191) so that it can be indexed.";
+        readonly output: {
+          readonly codecId: "sql/varchar@1";
+          readonly typeParams: {
+            readonly length: 191;
+          };
+        };
+      };
+      readonly Int: {
+        readonly kind: "typeConstructor";
+        readonly inferred: true;
+        readonly documentation: "A signed 32-bit integer stored as MySQL int and represented as a JavaScript number.";
+        readonly output: {
+          readonly codecId: "mysql/int@1";
+        };
+      };
+      readonly BigInt: {
+        readonly kind: "typeConstructor";
+        readonly inferred: true;
+        readonly documentation: "A signed 64-bit integer stored as MySQL bigint and represented as a JavaScript bigint.";
+        readonly output: {
+          readonly codecId: "mysql/bigint@1";
+        };
+      };
+      readonly DateTime: {
+        readonly kind: "typeConstructor";
+        readonly inferred: true;
+        readonly documentation: "A date and time with millisecond precision, stored as MySQL datetime(3) in UTC and represented as a JavaScript Date.";
+        readonly output: {
+          readonly codecId: "mysql/datetime@1";
+          readonly typeParams: {
+            readonly precision: 3;
+          };
+        };
+      };
+    };
+    readonly dataTypes: Readonly<Record<string, import("@prisma/orm-framework/components/authoring").DataTypeAuthoringEntry>>;
+    readonly textDataTypes: readonly import("@prisma/orm-framework/components/codec").DataTypeId[];
+  };
+  readonly generatorFunctions: readonly [{
+    readonly name: "uuid";
+    readonly signature: (dataTypes: import("@prisma/orm-framework/components/authoring").DataTypeSupport) => {
+      readonly documentation: "Generates a UUID when a value is not supplied.";
+      readonly positional: readonly [{
+        readonly key: "version";
+        readonly type: OptionalArgType<4 | 7, AttributeCtx, ArgType<4 | 7, AttributeCtx>>;
+        readonly documentation: "The UUID version: `4` or `7`. Defaults to `4`.";
+      }];
+    };
+    readonly bindings: readonly [];
+  }, {
+    readonly name: "cuid";
+    readonly signature: (dataTypes: import("@prisma/orm-framework/components/authoring").DataTypeSupport) => {
+      readonly documentation: "Generates a CUID2 identifier when a value is not supplied.";
+      readonly positional: readonly [{
+        readonly key: "version";
+        readonly type: ArgType<2, AttributeCtx>;
+        readonly documentation: "The CUID version. Only `2` is supported.";
+      }];
+    };
+    readonly bindings: readonly [];
+  }, {
+    readonly name: "nanoid";
+    readonly signature: (dataTypes: import("@prisma/orm-framework/components/authoring").DataTypeSupport) => {
+      readonly documentation: "Generates a Nano ID when a value is not supplied.";
+      readonly positional: readonly [{
+        readonly key: "size";
+        readonly type: OptionalArgType<number, AttributeCtx, ArgType<number, AttributeCtx>>;
+        readonly documentation: "The identifier length, from `2` through `255`. Defaults to 21.";
+      }];
+    };
+    readonly bindings: readonly [];
+  }, {
+    readonly name: "now";
+    readonly bindings: readonly [import("@prisma/orm-framework/components/components").GeneratorFunctionBinding];
+  }, ...import("@prisma/orm-framework/components/components").GeneratorFunctionContribution[]];
+  readonly controlMutationDefaults: {
+    readonly defaultFunctionRegistry: Map<any, any>;
+    readonly generatorDescriptors: readonly import("@prisma/orm-framework/components/control").MutationDefaultGeneratorDescriptor[];
+  };
+  readonly kind: "target";
+  readonly familyId: "sql";
+  readonly targetId: "mysql";
+  readonly id: "mysql";
+  readonly version: "0.0.1";
+  readonly capabilities: {};
+  readonly dataTypes: readonly import("@prisma/orm-framework/components/codec").DataType[];
+  readonly sessionSettings: {
+    readonly time_zone: "+00:00";
+  };
+  readonly __codecTypes?: CodecTypes;
+};
+declare const mysqlTargetDescriptorMeta: typeof mysqlTargetDescriptorMetaBase & {
+  readonly __codecTypes?: CodecTypes;
+  readonly __dataTypeArguments?: {
+    readonly 'mysql/int': {
+      readonly argument: number;
+      readonly parameter: number;
+    };
+  };
+};
+//#endregion
+export { mysqlTargetDescriptorMeta as t };
+//# sourceMappingURL=pack-YVG-iBMQ.d.mts.map