@abapify/acds 0.4.15 → 0.4.16

package/dist/index.d.mts

@@ -68,7 +68,7 @@ interface NamedTypeRef extends AstNode {
   name: string;
 }
 type TypeRef = BuiltinTypeRef | NamedTypeRef;
-/** Field in a table/structure/aspect body */
+/** Field in a table/structure/table-entity/external-entity body */
 interface FieldDefinition extends AstNode {
   annotations: Annotation[];
   name: string;
@@ -83,11 +83,15 @@ interface IncludeDirective extends AstNode {
   suffix?: string;
 }
 type TableMember = FieldDefinition | IncludeDirective;
-/** define table <name> { ... } */
+/** define [root] table [entity] <name> { ... } */
 interface TableDefinition extends AstNode {
   kind: 'table';
   name: string;
   annotations: Annotation[];
+  /** `true` for `define table entity` (CDS table entity, no DDIC table). */
+  entity?: boolean;
+  /** `true` for `define root table entity`. */
+  root?: boolean;
   members: TableMember[];
 }
 /** define structure <name> { ... } */
@@ -116,9 +120,11 @@ interface ExposeStatement extends AstNode {
   entity: string;
   alias?: string;
 }
-/** annotate entity <name> with { ... } */
+/** annotate entity|view <name> with { ... } */
 interface MetadataExtension extends AstNode {
   kind: 'metadataExtension';
+  /** `entity` for `annotate entity`, `view` for `annotate view`. */
+  targetKind?: 'entity' | 'view';
   entity: string;
   annotations: Annotation[];
   elements: AnnotatedElement[];
@@ -152,27 +158,163 @@ interface Cardinality extends AstNode {
   /** `undefined` means unbounded (`*`) when present. */
   max?: number | '*';
 }
+/** A cardinality bound written in words: `one`, `exact one` or `many`. */
+type CardinalityWord = 'one' | 'exactOne' | 'many';
+/**
+ * Word-form cardinality: `of {many|one|exact one} [to] <target>`
+ * for associations, and `[{one|many|exact one}] to {one|exact one|many}`
+ * for joins (`many to one join`, `to one join`).
+ */
+interface WordCardinality extends AstNode {
+  /**
+   * Source-side bound — only populated by join cardinalities
+   * (`many to one join`); `of`-form associations keep a single `target`.
+   */
+  source?: CardinalityWord;
+  /** Target-side bound. */
+  target: CardinalityWord;
+}
 type AssociationKind = 'association' | 'composition';
 interface AssociationDeclaration extends AstNode {
   kind: 'association';
   /** `association` or `composition` */
   associationKind: AssociationKind;
   annotations: Annotation[];
+  /** Bracket-form cardinality `[min..max]` / `[*]` / `[n]`. */
   cardinality?: Cardinality;
+  /**
+   * Word-form cardinality (`of many to one X`, `to exact one X`).
+   * Absent when the bracket form is used or no cardinality is given.
+   */
+  wordCardinality?: WordCardinality;
   /** `of many` / `of one` modifier (optional). */
   targetMultiplicity?: 'many' | 'one';
+  /** `association to parent <target>` (CDS to-parent association). */
+  toParent?: boolean;
   /** Fully qualified target entity (e.g. `I_SalesOrder`). */
   target: string;
   /** `to redirected to <target>` (projection association). */
   redirected?: boolean;
   alias?: string;
   on?: Expression;
+  /** `with default filter <condition>` — projection associations. */
+  withDefaultFilter?: Expression;
+}
+/**
+ * `redefine association|composition <name> [<filter>] [as <alias>]
+ *  [redirected to …]` — a redefined association of a projection view,
+ * declared in the header before the projection list.
+ */
+interface RedefinedAssociation extends AstNode {
+  kind: 'redefinedAssociation';
+  associationKind: AssociationKind;
+  /** Qualified association name (optionally `source._assoc`). */
+  name: string;
+  /** Filter clause `[<card>:] <cond>` (raw, opaque). */
+  filter?: Expression;
+  alias?: string;
+  redirectedTo?: AssociationRedirection;
+}
+/** `redirected to [composition child|parent] <target>` */
+interface AssociationRedirection extends AstNode {
+  /** `default` = `redirected to`, else `composition child` / `parent`. */
+  mode: 'default' | 'compositionChild' | 'parent';
+  target: string;
+}
+/**
+ * `bind aspect <aspect> ( <element> => <target>, … ) [as <alias>]`
+ * — an aspect binding in the FROM region or projection view header.
+ */
+interface AspectBinding extends AstNode {
+  kind: 'aspectBinding';
+  /** Bound aspect entity name. */
+  aspect: string;
+  mappings: AspectBindingMapping[];
+  alias?: string;
+}
+interface AspectBindingMapping extends AstNode {
+  /** Aspect element name. */
+  element: string;
+  /** Binding target, e.g. `$projection.field` (raw operand text). */
+  target: string;
 }
 type DataSourceKind = 'select' | 'projection';
+/**
+ * Normalized join type.
+ *
+ * The different surface spellings are folded into one vocabulary so that
+ * downstream consumers (dependency / lineage tooling) do not have to know
+ * about surface syntax:
+ *
+ * | spelling              | normalized   |
+ * |-----------------------|--------------|
+ * | `JOIN`                | `inner`      |
+ * | `INNER JOIN`          | `inner`      |
+ * | `LEFT JOIN`           | `leftOuter`  |
+ * | `LEFT OUTER JOIN`     | `leftOuter`  |
+ * | `RIGHT JOIN`          | `rightOuter` |
+ * | `RIGHT OUTER JOIN`    | `rightOuter` |
+ * | `FULL JOIN`           | `fullOuter`  |
+ * | `FULL OUTER JOIN`     | `fullOuter`  |
+ * | `CROSS JOIN`          | `cross`      |
+ */
+type JoinType = 'inner' | 'leftOuter' | 'rightOuter' | 'fullOuter' | 'cross';
+/**
+ * A single parameter binding of a parameterized data source.
+ *
+ * `value` keeps the original binding text, e.g. `:P_StartDate` (reference to
+ * a parameter of the consuming view), `$session.client` / `$parameters.P_X`
+ * (system variable) or a literal such as `'X'` / `42`.
+ */
+interface DataSourceParameter extends AstNode {
+  /** Name of the target parameter, e.g. `P_StartDate`. */
+  name: string;
+  /** Raw binding text as written in the source. */
+  value: string;
+}
+/** A data source in a FROM clause: a view, table, projection or parameter. */
 interface DataSource extends AstNode {
   name: string;
   alias?: string;
+  /** Parameter bindings — present for parameterized sources only. */
+  parameters?: DataSourceParameter[];
+}
+/**
+ * A parenthesized join group: `join (A join B on …) on …`.
+ * The group acts as a single join source; its `joins` chain is evaluated
+ * inside the parentheses.
+ */
+interface JoinGroup extends AstNode {
+  kind: 'joinGroup';
+  source: JoinSource;
+  joins: JoinClause[];
+}
+/** A join source is either a plain data source or a parenthesized group. */
+type JoinSource = DataSource | JoinGroup;
+/** A join whose `ON` condition is required (inner/left/right/full). */
+interface ConditionedJoinClause extends AstNode {
+  kind: 'join';
+  joinType: 'inner' | 'leftOuter' | 'rightOuter' | 'fullOuter';
+  source: JoinSource;
+  /** The `ON` condition, captured opaquely — always present. */
+  on: Expression;
+  /** Optional word-form join cardinality (`many to one join`). */
+  cardinality?: WordCardinality;
+}
+/** A cross join — never carries an `ON` condition. */
+interface CrossJoinClause extends AstNode {
+  kind: 'join';
+  joinType: 'cross';
+  source: JoinSource;
+  on?: never;
+  cardinality?: never;
 }
+/**
+ * A join in a FROM clause. The discriminated union encodes the grammar
+ * invariant: `on` is mandatory for conditioned joins and forbidden for
+ * `cross` joins.
+ */
+type JoinClause = ConditionedJoinClause | CrossJoinClause;
 /** Single element in a view's projection list. */
 interface ViewElement extends AstNode {
   annotations: Annotation[];
@@ -182,21 +324,90 @@ interface ViewElement extends AstNode {
   /** Either a typed field (abstract/custom entities) or projection expression. */
   expression: string;
   alias?: string;
+  /** `<element> : localized` (projection views). */
+  localized?: boolean;
+  /** `<assoc> : redirected to [composition child|parent] <target>`. */
+  redirectedTo?: AssociationRedirection;
   /** Present only when element is a typed field (`name : type`). */
   type?: TypeRef;
   notNull?: boolean;
 }
 type ViewMember = ViewElement | AssociationDeclaration;
+/**
+ * The `select` part of a view entity (or a set-operation operand):
+ * `select [distinct] from <source> [joins|assocs|bind aspect] { … }
+ *  [where …] [group by …] [having …] [union|intersect|except …]*`.
+ */
+interface SelectStatement extends AstNode {
+  kind: 'selectStatement';
+  distinct?: boolean;
+  source: DataSource;
+  joins: JoinClause[];
+  fromAssociations?: AssociationDeclaration[];
+  aspectBindings?: AspectBinding[];
+  members: ViewMember[];
+  where?: Expression;
+  groupBy?: string[];
+  having?: Expression;
+  setOperations?: SetOperation[];
+}
+/**
+ * `union [all] | intersect | except select …` — a set operation whose operand
+ * is a complete nested select statement.
+ */
+interface SetOperation extends AstNode {
+  kind: 'setOperation';
+  operator: 'union' | 'unionAll' | 'intersect' | 'except';
+  statement: SelectStatement;
+}
 interface ViewEntityDefinition extends AstNode {
   kind: 'viewEntity';
   name: string;
   annotations: Annotation[];
+  /**
+   * `true` for the legacy `define view <name>` syntax (classic SQL view).
+   * Absent for `define view entity <name>`.
+   */
+  legacy?: boolean;
+  /** `define root view entity`. */
+  root?: boolean;
+  /** `define writable view entity`. */
+  writable?: boolean;
+  /** `provider contract <name>` (projection views). */
+  providerContract?: string;
   sourceKind: DataSourceKind;
+  /** `select distinct`. */
+  distinct?: boolean;
   source: DataSource;
+  /**
+   * Ordered join chain applied to {@link source}. Empty when the view has no
+   * joins. The first entry is joined against `source`, the second against the
+   * result of the first, and so on.
+   */
+  joins: JoinClause[];
+  /**
+   * Associations declared in the FROM region (between the data source and
+   * the element list). Distinct from the associations declared inside the
+   * element list, which are part of {@link members}.
+   */
+  fromAssociations?: AssociationDeclaration[];
+  /**
+   * `redefine association|composition …` declarations of a projection view,
+   * placed in the header before the projection list.
+   */
+  redefinedAssociations?: RedefinedAssociation[];
+  /** `bind aspect …` declarations in the FROM region / projection header. */
+  aspectBindings?: AspectBinding[];
   parameters: ParameterDefinition[];
   members: ViewMember[];
   /** Top-level filter clause (`where ...`). */
   where?: Expression;
+  /** `group by field1, …`. */
+  groupBy?: string[];
+  /** `having <condition>`. */
+  having?: Expression;
+  /** `union|intersect|except` set operations applied to the select. */
+  setOperations?: SetOperation[];
 }
 interface AbstractEntityDefinition extends AstNode {
   kind: 'abstractEntity';
@@ -217,15 +428,204 @@ interface GrantStatement extends AstNode {
   privilege: 'select';
   /** Target entity (qualified). */
   entity: string;
+  /** `with optional elements ( <name> [default true|false], … )`. */
+  optionalElements?: DclOptionalElement[];
+  /** `combination mode or|and` or `redefinition` after grant. */
+  combinationMode?: 'or' | 'and' | 'redefinition';
+  /** `inherit <role> …` — the role whose conditions are inherited. */
+  inheritRole?: string;
+  /** `inherit <role> and|or <cond>` connector. */
+  inheritConditionConnector?: 'and' | 'or';
+  inheritCondition?: Expression;
+  where?: Expression;
+}
+/** One entry of `with optional elements ( <name> [default true|false] )`. */
+interface DclOptionalElement extends AstNode {
+  name: string;
+  /** `default true|false`; absent when not specified. */
+  default?: boolean;
+}
+/**
+ * `inherit <role> [for grant select on <entity>] [where …] ;` —
+ * a standalone inherit rule inside a role body.
+ */
+interface InheritStatement extends AstNode {
+  /** The inherited role (qualified). */
+  role: string;
+  /** `for grant select on <entity>` — restricted scope. */
+  entity?: string;
   where?: Expression;
 }
+/**
+ * `inheriting conditions from entity <name>|super [default true|false] … ;`
+ */
+interface InheritingConditionsStatement extends AstNode {
+  /** `entity` or `super`. */
+  sourceKind: 'entity' | 'super';
+  /** Present for `from entity <name>`. */
+  entity?: string;
+  /** `default true|false`; absent when not specified. */
+  default?: boolean;
+  condition?: Expression;
+}
+/** One statement inside a role body. */
+type RoleMember = GrantStatement | InheritStatement | InheritingConditionsStatement;
 interface RoleDefinition extends AstNode {
   kind: 'role';
   name: string;
   annotations: Annotation[];
+  /** `define role <name> switchable { … }`. */
+  switchable?: boolean;
+  /** `grant select on …` statements. */
   grants: GrantStatement[];
+  /** All members in source order, including inherit rules. */
+  members: RoleMember[];
+}
+/** define [writable] external entity <name> … with federated data provided at runtime [;] */
+interface ExternalEntityDefinition extends AstNode {
+  kind: 'externalEntity';
+  name: string;
+  annotations: Annotation[];
+  /** `writable` modifier (writable external entity). */
+  writable?: boolean;
+  /** `external name <db_object>` mapping. */
+  externalName?: string;
+  parameters: ParameterDefinition[];
+  members: TableMember[];
+}
+/** define table function <name> [with parameters …] returns { … } implemented by method cls=>m [;] */
+interface TableFunctionDefinition extends AstNode {
+  kind: 'tableFunction';
+  name: string;
+  annotations: Annotation[];
+  parameters: ParameterDefinition[];
+  /** Return structure fields (`name : typing;`). */
+  members: TableMember[];
+  /** `implemented by method <class>` (part before `=>`). */
+  implementingClass?: string;
+  /** `implemented by method <class>=><method>` (part after `=>`). */
+  implementingMethod?: string;
+}
+/** define scalar function <name> [with parameters …] returns <type> [;] */
+interface ScalarFunctionDefinition extends AstNode {
+  kind: 'scalarFunction';
+  name: string;
+  annotations: Annotation[];
+  parameters: ParameterDefinition[];
+  returnType: TypeRef;
+}
+/** `[key] <elem> : <typing|expr>;` — one element of a `define aspect` body. */
+interface AspectElement extends AstNode {
+  annotations: Annotation[];
+  name: string;
+  isKey: boolean;
+  /** `elem : typing` — present when the element is typed. */
+  type?: TypeRef;
+  /** `elem : <expr>` — raw operand text for expressions/calls/case. */
+  expression?: string;
 }
-type CdsDefinition = TableDefinition | StructureDefinition | SimpleTypeDefinition | ServiceDefinition | MetadataExtension | RoleDefinition | ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition;
+/** define aspect <name> [{ <elements> }] */
+interface AspectDefinition extends AstNode {
+  kind: 'aspect';
+  name: string;
+  annotations: Annotation[];
+  members: AspectElement[];
+}
+/** One `ORDER BY` item: `<field> [ascending|descending]`. */
+interface SortItem extends AstNode {
+  name: string;
+  direction?: 'ascending' | 'descending';
+}
+/** Period clause of a hierarchy: `period from <f> to <f> [valid from <f> to <f>]`. */
+interface HierarchyPeriod extends AstNode {
+  from: string;
+  to: string;
+  validFrom?: string;
+  validTo?: string;
+}
+/**
+ * define hierarchy <name> [with parameters …]
+ *   as parent child hierarchy( <clauses> ) { <elements> }
+ */
+interface HierarchyDefinition extends AstNode {
+  kind: 'hierarchy';
+  name: string;
+  annotations: Annotation[];
+  parameters: ParameterDefinition[];
+  /** `source <entity>` — the hierarchy's data source. */
+  source: string;
+  /** `child to parent association <name>` — the self-association. */
+  childToParentAssociation?: string;
+  period?: HierarchyPeriod;
+  /** `directory <entity> filter by <cond>`. */
+  directory?: {
+    entity: string;
+    filter: Expression;
+  };
+  /** `start where <cond>`. */
+  startWhere?: Expression;
+  /** `siblings order by <items>` — always present. */
+  siblingsOrderBy: SortItem[];
+  /** `depth <field>|<num>`. */
+  depth?: string;
+  /** `nodetype <field>`. */
+  nodetype?: string;
+  /** `load bulk|incremental|<field>|<sysvar>`. */
+  load?: string;
+  /** `multiple parents not allowed|leaves only|allowed`. */
+  multipleParents?: 'notAllowed' | 'leavesOnly' | 'allowed';
+  /** `orphans ignore|error|root`. */
+  orphans?: 'ignore' | 'error' | 'root';
+  /** `cycles error|breakup`. */
+  cycles?: 'error' | 'breakup';
+  /** `generate spantree`. */
+  generateSpantree?: boolean;
+  /** `cache on|off|force`. */
+  cache?: 'on' | 'off' | 'force';
+  members: ViewMember[];
+}
+/** `union|intersect|except [all] { <elements> }` — extension-level set op. */
+interface ExtendSetOperation extends AstNode {
+  kind: 'extendSetOperation';
+  operator: 'union' | 'unionAll' | 'intersect' | 'except';
+  members: ViewMember[];
+}
+/**
+ * `extend view [entity] <name> with [<assocs>] { <elements> }
+ *  [group by …] [union|intersect|except { … }]* [;]`
+ * and `extend abstract|custom entity <name> with { … }`.
+ */
+interface ExtensionDefinition extends AstNode {
+  kind: 'extension';
+  name: string;
+  annotations: Annotation[];
+  /** The extended entity flavour: `view` | `abstract` | `custom`. */
+  targetKind: 'view' | 'abstract' | 'custom';
+  /** `true` when the extended target is `view entity` (not legacy `view`). */
+  isViewEntity?: boolean;
+  /** Associations appended by the extension. */
+  associations: AssociationDeclaration[];
+  members: ViewMember[];
+  groupBy?: string[];
+  setOperations?: ExtendSetOperation[];
+}
+/** `define annotation <name> { … }` (DDLA) — body captured as raw tokens. */
+interface AnnotationDefinition extends AstNode {
+  kind: 'annotationDefinition';
+  name: string;
+  annotations: Annotation[];
+  /** Raw token text inside the `{ … }` body (or after `:`). */
+  body: string;
+}
+/** `define accesspolicy <name> { … }` — body captured as raw tokens. */
+interface AccessPolicyDefinition extends AstNode {
+  kind: 'accessPolicy';
+  name: string;
+  annotations: Annotation[];
+  /** Raw token text inside the `{ … }` body. */
+  body: string;
+}
+type CdsDefinition = TableDefinition | StructureDefinition | SimpleTypeDefinition | ServiceDefinition | MetadataExtension | RoleDefinition | ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition | ExternalEntityDefinition | TableFunctionDefinition | ScalarFunctionDefinition | AspectDefinition | HierarchyDefinition | ExtensionDefinition | AnnotationDefinition | AccessPolicyDefinition;
 /** Root AST node representing a parsed CDS source file */
 interface CdsSourceFile extends AstNode {
   definitions: CdsDefinition[];
@@ -241,9 +641,9 @@ interface CdsParseError {
 }
 //#endregion
 //#region src/lib/ast/walker.d.ts
-type WithMembers = ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition;
-type WithFields = TableDefinition | StructureDefinition;
-type WithParameters = ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition;
+type WithMembers = ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition | HierarchyDefinition | ExtensionDefinition;
+type WithFields = TableDefinition | StructureDefinition | ExternalEntityDefinition | TableFunctionDefinition;
+type WithParameters = ViewEntityDefinition | AbstractEntityDefinition | CustomEntityDefinition | ExternalEntityDefinition | TableFunctionDefinition | ScalarFunctionDefinition | HierarchyDefinition;
 /** True when the definition has a `members` array (view-like entities). */
 declare function hasMembers(def: CdsDefinition): def is WithMembers;
 /** True when the definition has a `members` array of typed fields (TABL/structure). */
@@ -266,6 +666,22 @@ declare function walkAssociations(file: CdsSourceFile): Iterable<{
   owner: WithMembers;
   association: AssociationDeclaration;
 }>;
+/**
+ * Yield every association declared in the FROM region of a view entity.
+ *
+ * FROM associations are declared next to the data source (before the element
+ * list) and are therefore kept apart from the associations inside
+ * `members`.
+ */
+declare function walkFromAssociations(file: CdsSourceFile): Iterable<{
+  owner: ViewEntityDefinition;
+  association: AssociationDeclaration;
+}>;
+/** Yield every join of every view entity, in source order. */
+declare function walkJoins(file: CdsSourceFile): Iterable<{
+  owner: ViewEntityDefinition;
+  join: JoinClause;
+}>;
 /** Yield every field definition from tables and structures. */
 declare function walkFields(file: CdsSourceFile): Iterable<{
   owner: WithFields;
@@ -310,6 +726,9 @@ declare const annotationsCoverage: GrammarCoverage;
 //#region src/lib/grammar/associations.d.ts
 declare const associationsCoverage: GrammarCoverage;
 //#endregion
+//#region src/lib/grammar/joins.d.ts
+declare const joinsCoverage: GrammarCoverage;
+//#endregion
 //#region src/lib/grammar/parameters.d.ts
 declare const parametersCoverage: GrammarCoverage;
 //#endregion
@@ -353,5 +772,5 @@ interface ParseResult {
  */
 declare function parse(source: string): ParseResult;
 //#endregion
-export { type AbstractEntityDefinition, type AnnotatedElement, type Annotation, type AnnotationArray, type AnnotationObject, type AnnotationProperty, type AnnotationValue, type AssociationDeclaration, type AssociationKind, type AstNode, type BooleanLiteral, type BuiltinTypeRef, type Cardinality, type CdsDefinition, type CdsParseError, type CdsSourceFile, type CustomEntityDefinition, type DataSource, type DataSourceKind, type EnumValue, type ExposeStatement, type Expression, type FieldDefinition, GRAMMAR_COVERAGE, type GrammarCoverage, type GrantStatement, type IncludeDirective, type MetadataExtension, type NamedTypeRef, type NumberLiteral, type ParameterDefinition, ParseResult, type RoleDefinition, type SemanticDiagnostic, type ServiceDefinition, type SimpleTypeDefinition, type SourceLocation, type StringLiteral, type StructureDefinition, type TableDefinition, type TableMember, type TypeRef, type ViewElement, type ViewEntityDefinition, type ViewMember, actionsCoverage, annotationsCoverage, associationsCoverage, dclCoverage, ddlCoverage, findAnnotation, hasFields, hasMembers, hasParameters, isAssociation, parametersCoverage, parse, projectionsCoverage, validate, validateCardinality, validateViewElements, walkAnnotations, walkAssociations, walkDefinitions, walkFields, walkParameters, walkViewElements };
+export { type AbstractEntityDefinition, type AccessPolicyDefinition, type AnnotatedElement, type Annotation, type AnnotationArray, type AnnotationDefinition, type AnnotationObject, type AnnotationProperty, type AnnotationValue, type AspectBinding, type AspectBindingMapping, type AspectDefinition, type AspectElement, type AssociationDeclaration, type AssociationKind, type AssociationRedirection, type AstNode, type BooleanLiteral, type BuiltinTypeRef, type Cardinality, type CardinalityWord, type CdsDefinition, type CdsParseError, type CdsSourceFile, type ConditionedJoinClause, type CrossJoinClause, type CustomEntityDefinition, type DataSource, type DataSourceKind, type DataSourceParameter, type DclOptionalElement, type EnumValue, type ExposeStatement, type Expression, type ExtendSetOperation, type ExtensionDefinition, type ExternalEntityDefinition, type FieldDefinition, GRAMMAR_COVERAGE, type GrammarCoverage, type GrantStatement, type HierarchyDefinition, type HierarchyPeriod, type IncludeDirective, type InheritStatement, type InheritingConditionsStatement, type JoinClause, type JoinGroup, type JoinSource, type JoinType, type MetadataExtension, type NamedTypeRef, type NumberLiteral, type ParameterDefinition, ParseResult, type RedefinedAssociation, type RoleDefinition, type RoleMember, type ScalarFunctionDefinition, type SelectStatement, type SemanticDiagnostic, type ServiceDefinition, type SetOperation, type SimpleTypeDefinition, type SortItem, type SourceLocation, type StringLiteral, type StructureDefinition, type TableDefinition, type TableFunctionDefinition, type TableMember, type TypeRef, type ViewElement, type ViewEntityDefinition, type ViewMember, type WordCardinality, actionsCoverage, annotationsCoverage, associationsCoverage, dclCoverage, ddlCoverage, findAnnotation, hasFields, hasMembers, hasParameters, isAssociation, joinsCoverage, parametersCoverage, parse, projectionsCoverage, validate, validateCardinality, validateViewElements, walkAnnotations, walkAssociations, walkDefinitions, walkFields, walkFromAssociations, walkJoins, walkParameters, walkViewElements };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/ast.ts","../src/errors.ts","../src/lib/ast/walker.ts","../src/lib/validate/cardinality.ts","../src/lib/validate/elements.ts","../src/lib/validate/index.ts","../src/lib/grammar/ddl.ts","../src/lib/grammar/dcl.ts","../src/lib/grammar/annotations.ts","../src/lib/grammar/associations.ts","../src/lib/grammar/parameters.ts","../src/lib/grammar/projections.ts","../src/lib/grammar/actions.ts","../src/lib/grammar/index.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/ast.ts","../src/errors.ts","../src/lib/ast/walker.ts","../src/lib/validate/cardinality.ts","../src/lib/validate/elements.ts","../src/lib/validate/index.ts","../src/lib/grammar/ddl.ts","../src/lib/grammar/dcl.ts","../src/lib/grammar/annotations.ts","../src/lib/grammar/associations.ts","../src/lib/grammar/joins.ts","../src/lib/grammar/parameters.ts","../src/lib/grammar/projections.ts","../src/lib/grammar/actions.ts","../src/lib/grammar/index.ts","../src/index.ts"],"mappings":"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"}