agentlang/out/language/generated/ast.d.ts

The easiest way to build the most reliable AI agents - enterprise-grade teams of AI agents that collaborate with each other and humans

/******************************************************************************
 * This file was generated by langium-cli 3.5.2.
 * DO NOT EDIT MANUALLY!
 ******************************************************************************/
import * as langium from 'langium';
export declare const AgentlangTerminals: {
    ID: RegExp;
    STRING: RegExp;
    INT: RegExp;
    WS: RegExp;
    ML_COMMENT: RegExp;
    SL_COMMENT: RegExp;
};
export type AgentlangTerminalNames = keyof typeof AgentlangTerminals;
export type AgentlangKeywordNames = "!=" | "(" | ")" | "*" | "+" | "," | "-" | "-->" | "." | "/" | ":" | ";" | "<" | "<=" | "<>" | "=" | "==" | ">" | ">=" | "?" | "@" | "@actions" | "@after" | "@as" | "@async" | "@before" | "@catch" | "@distinct" | "@enum" | "@expr" | "@from" | "@full_join" | "@inner_join" | "@into" | "@join" | "@left_join" | "@meta" | "@oneof" | "@public" | "@rbac" | "@ref" | "@right_join" | "@then" | "@upsert" | "@with_unique" | "[" | "]" | "agent" | "agentlang/retry" | "allow" | "and" | "attempts" | "await" | "backoff" | "between" | "case" | "commitTransaction" | "contains" | "create" | "decision" | "delete" | "directive" | "else" | "entity" | "error" | "event" | "extends" | "false" | "flow" | "for" | "glossaryEntry" | "if" | "import" | "in" | "like" | "module" | "not" | "not_found" | "onSubscription" | "or" | "purge" | "query" | "read" | "record" | "relationship" | "resolver" | "return" | "roles" | "rollbackTransaction" | "scenario" | "startTransaction" | "subscribe" | "true" | "update" | "upsert" | "where" | "workflow" | "{" | "}";
export type AgentlangTokenNames = AgentlangTerminalNames | AgentlangKeywordNames;
export type AttributeValueExpression = Expr;
export declare const AttributeValueExpression = "AttributeValueExpression";
export declare function isAttributeValueExpression(item: unknown): item is AttributeValueExpression;
export type Boolean = 'false' | 'true';
export declare function isBoolean(item: unknown): item is Boolean;
export type Decimal = number;
export declare function isDecimal(item: unknown): item is Decimal;
export type Definition = AgentDefinition | DecisionDefinition | DirectiveDefinition | FlowDefinition | GlossaryEntryDefinition | PublicAgentDefinition | PublicWorkflowDefinition | RelationshipDefinition | ResolverDefinition | RetryDefinition | ScenarioDefinition | SchemaDefinition | StandaloneStatement | WorkflowDefinition;
export declare const Definition = "Definition";
export declare function isDefinition(item: unknown): item is Definition;
export type Expr = BinExpr | PrimExpr;
export declare const Expr = "Expr";
export declare function isExpr(item: unknown): item is Expr;
export type FlowStepSpec = CrudMap;
export declare const FlowStepSpec = "FlowStepSpec";
export declare function isFlowStepSpec(item: unknown): item is FlowStepSpec;
export type GenericName = string;
export declare function isGenericName(item: unknown): item is GenericName;
export type JoinType = '@full_join' | '@inner_join' | '@join' | '@left_join' | '@right_join';
export declare function isJoinType(item: unknown): item is JoinType;
export type PrimExpr = Group | Literal | NegExpr | NotExpr;
export declare const PrimExpr = "PrimExpr";
export declare function isPrimExpr(item: unknown): item is PrimExpr;
export type QualifiedName = Ref | string;
export declare function isQualifiedName(item: unknown): item is QualifiedName;
export type QueryId = string;
export declare function isQueryId(item: unknown): item is QueryId;
export type Ref = string;
export declare function isRef(item: unknown): item is Ref;
export type SchemaDefinition = EntityDefinition | EventDefinition | PublicEventDefinition | RecordDefinition;
export declare const SchemaDefinition = "SchemaDefinition";
export declare function isSchemaDefinition(item: unknown): item is SchemaDefinition;
export type SqlComparisonOpr = '!=' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';
export declare function isSqlComparisonOpr(item: unknown): item is SqlComparisonOpr;
export type TaggedId = string;
export declare function isTaggedId(item: unknown): item is TaggedId;
export type WorkflowHeaderPrefix = 'create' | 'delete' | 'update';
export declare function isWorkflowHeaderPrefix(item: unknown): item is WorkflowHeaderPrefix;
export type WorkflowHeaderTag = '@after' | '@before';
export declare function isWorkflowHeaderTag(item: unknown): item is WorkflowHeaderTag;
export interface ActionEntry extends langium.AstNode {
    readonly $container: EntityActionsDefinitions;
    readonly $type: 'ActionEntry';
    event: string;
    name: string;
}
export declare const ActionEntry = "ActionEntry";
export declare function isActionEntry(item: unknown): item is ActionEntry;
export interface AfterTriggerDefinition extends langium.AstNode {
    readonly $container: PrePostTriggerDefinition;
    readonly $type: 'AfterTriggerDefinition';
    triggers: TriggerDefinition;
}
export declare const AfterTriggerDefinition = "AfterTriggerDefinition";
export declare function isAfterTriggerDefinition(item: unknown): item is AfterTriggerDefinition;
export interface AgentDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicAgentDefinition;
    readonly $type: 'AgentDefinition';
    body?: GenericDefBody;
    name: GenericName;
}
export declare const AgentDefinition = "AgentDefinition";
export declare function isAgentDefinition(item: unknown): item is AgentDefinition;
export interface AgentXtraAttribute extends langium.AstNode {
    readonly $container: AgentXtraSpec;
    readonly $type: 'AgentXtraAttribute' | 'Ref';
    name: string;
    value: string;
}
export declare const AgentXtraAttribute = "AgentXtraAttribute";
export declare function isAgentXtraAttribute(item: unknown): item is AgentXtraAttribute;
export interface AgentXtraSpec extends langium.AstNode {
    readonly $container: GlossaryEntryDefinition;
    readonly $type: 'AgentXtraSpec';
    attributes: Array<AgentXtraAttribute>;
}
export declare const AgentXtraSpec = "AgentXtraSpec";
export declare function isAgentXtraSpec(item: unknown): item is AgentXtraSpec;
export interface AliasSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'AliasSpec';
    alias?: string;
    aliases: Array<string>;
}
export declare const AliasSpec = "AliasSpec";
export declare function isAliasSpec(item: unknown): item is AliasSpec;
export interface ArrayLiteral extends langium.AstNode {
    readonly $container: Literal;
    readonly $type: 'ArrayLiteral';
    vals: Array<Statement>;
}
export declare const ArrayLiteral = "ArrayLiteral";
export declare function isArrayLiteral(item: unknown): item is ArrayLiteral;
export interface AsyncFnCall extends langium.AstNode {
    readonly $container: Literal;
    readonly $type: 'AsyncFnCall';
    fnCall: FnCall;
}
export declare const AsyncFnCall = "AsyncFnCall";
export declare function isAsyncFnCall(item: unknown): item is AsyncFnCall;
export interface AttributeDefinition extends langium.AstNode {
    readonly $container: RecordSchemaDefinition;
    readonly $type: 'AttributeDefinition';
    arrayType?: QualifiedName;
    enumSpec?: EnumSpec;
    expr?: Expr;
    name: string;
    oneOfSpec?: OneOfSpec;
    properties: Array<PropertyDefinition>;
    refSpec?: RefSpec;
    type?: QualifiedName;
}
export declare const AttributeDefinition = "AttributeDefinition";
export declare function isAttributeDefinition(item: unknown): item is AttributeDefinition;
export interface BackoffSpec extends langium.AstNode {
    readonly $container: RetryDefinition;
    readonly $type: 'BackoffSpec';
    attributes: Array<SetAttribute>;
}
export declare const BackoffSpec = "BackoffSpec";
export declare function isBackoffSpec(item: unknown): item is BackoffSpec;
export interface BeforeTriggerDefinition extends langium.AstNode {
    readonly $container: PrePostTriggerDefinition;
    readonly $type: 'BeforeTriggerDefinition';
    triggers: TriggerDefinition;
}
export declare const BeforeTriggerDefinition = "BeforeTriggerDefinition";
export declare function isBeforeTriggerDefinition(item: unknown): item is BeforeTriggerDefinition;
export interface BinExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'BinExpr';
    e1: Expr | PrimExpr;
    e2: Expr | PrimExpr;
    op: '!=' | '*' | '+' | '-' | '/' | '<' | '<=' | '<>' | '==' | '>' | '>=' | 'and' | 'in' | 'like' | 'or';
}
export declare const BinExpr = "BinExpr";
export declare function isBinExpr(item: unknown): item is BinExpr;
export interface CaseEntry extends langium.AstNode {
    readonly $container: DecisionDefBody;
    readonly $type: 'CaseEntry';
    cond: Expr;
    statements: Array<Statement>;
}
export declare const CaseEntry = "CaseEntry";
export declare function isCaseEntry(item: unknown): item is CaseEntry;
export interface CatchSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'CatchSpec';
    handlers: Array<Handler>;
}
export declare const CatchSpec = "CatchSpec";
export declare function isCatchSpec(item: unknown): item is CatchSpec;
export interface CompositeUniqueDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'CompositeUniqueDefinition';
    attrs: Array<string>;
}
export declare const CompositeUniqueDefinition = "CompositeUniqueDefinition";
export declare function isCompositeUniqueDefinition(item: unknown): item is CompositeUniqueDefinition;
export interface ConditionalFlowStep extends langium.AstNode {
    readonly $container: FlowEntry;
    readonly $type: 'ConditionalFlowStep';
    expr: string;
    next: FlowStepSpec;
}
export declare const ConditionalFlowStep = "ConditionalFlowStep";
export declare function isConditionalFlowStep(item: unknown): item is ConditionalFlowStep;
export interface CrudMap extends langium.AstNode {
    readonly $container: ConditionalFlowStep | FlowEntry | Pattern;
    readonly $type: 'CrudMap';
    body?: CrudMapBody;
    distinct: Array<'@distinct'>;
    into?: SelectIntoSpec;
    join?: JoinSpec;
    name: QualifiedName | QueryId;
    relationships: Array<RelationshipPattern>;
    source?: Literal;
    upsert: Array<'@upsert'>;
}
export declare const CrudMap = "CrudMap";
export declare function isCrudMap(item: unknown): item is CrudMap;
export interface CrudMapBody extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'CrudMapBody';
    attributes: Array<SetAttribute>;
    properties: Array<PropertyDefinition>;
}
export declare const CrudMapBody = "CrudMapBody";
export declare function isCrudMapBody(item: unknown): item is CrudMapBody;
export interface DecisionDefBody extends langium.AstNode {
    readonly $container: DecisionDefinition;
    readonly $type: 'DecisionDefBody';
    cases: Array<CaseEntry>;
}
export declare const DecisionDefBody = "DecisionDefBody";
export declare function isDecisionDefBody(item: unknown): item is DecisionDefBody;
export interface DecisionDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'DecisionDefinition';
    body?: DecisionDefBody;
    name: GenericName;
}
export declare const DecisionDefinition = "DecisionDefinition";
export declare function isDecisionDefinition(item: unknown): item is DecisionDefinition;
export interface Delete extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Delete';
    pattern: Pattern;
}
export declare const Delete = "Delete";
export declare function isDelete(item: unknown): item is Delete;
export interface DirectiveDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'DirectiveDefinition';
    body?: MapLiteral;
    dir?: If;
    name: Ref;
}
export declare const DirectiveDefinition = "DirectiveDefinition";
export declare function isDirectiveDefinition(item: unknown): item is DirectiveDefinition;
export interface Else extends langium.AstNode {
    readonly $container: If;
    readonly $type: 'Else';
    statements: Array<Statement>;
}
export declare const Else = "Else";
export declare function isElse(item: unknown): item is Else;
export interface EntityActionsDefinitions extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'EntityActionsDefinitions';
    entries: Array<ActionEntry>;
}
export declare const EntityActionsDefinitions = "EntityActionsDefinitions";
export declare function isEntityActionsDefinitions(item: unknown): item is EntityActionsDefinitions;
export interface EntityDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'EntityDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}
export declare const EntityDefinition = "EntityDefinition";
export declare function isEntityDefinition(item: unknown): item is EntityDefinition;
export interface EnumSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'EnumSpec';
    type?: QualifiedName;
    values: Array<string>;
}
export declare const EnumSpec = "EnumSpec";
export declare function isEnumSpec(item: unknown): item is EnumSpec;
export interface EventDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicEventDefinition;
    readonly $type: 'EventDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}
export declare const EventDefinition = "EventDefinition";
export declare function isEventDefinition(item: unknown): item is EventDefinition;
export interface ExtendsClause extends langium.AstNode {
    readonly $container: EntityDefinition | EventDefinition | RecordDefinition;
    readonly $type: 'ExtendsClause';
    parentName: QualifiedName;
}
export declare const ExtendsClause = "ExtendsClause";
export declare function isExtendsClause(item: unknown): item is ExtendsClause;
export interface FlowDefBody extends langium.AstNode {
    readonly $container: FlowDefinition;
    readonly $type: 'FlowDefBody';
    entries: Array<FlowEntry>;
}
export declare const FlowDefBody = "FlowDefBody";
export declare function isFlowDefBody(item: unknown): item is FlowDefBody;
export interface FlowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'FlowDefinition';
    body?: FlowDefBody;
    name: GenericName;
}
export declare const FlowDefinition = "FlowDefinition";
export declare function isFlowDefinition(item: unknown): item is FlowDefinition;
export interface FlowEntry extends langium.AstNode {
    readonly $container: FlowDefBody;
    readonly $type: 'FlowEntry';
    cond?: ConditionalFlowStep;
    next?: FlowStepSpec;
    root: GenericName;
}
export declare const FlowEntry = "FlowEntry";
export declare function isFlowEntry(item: unknown): item is FlowEntry;
export interface FnCall extends langium.AstNode {
    readonly $container: AsyncFnCall | Literal;
    readonly $type: 'FnCall';
    args: Array<Expr>;
    name: Ref | string;
}
export declare const FnCall = "FnCall";
export declare function isFnCall(item: unknown): item is FnCall;
export interface ForEach extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'ForEach';
    src: Pattern;
    statements: Array<Statement>;
    var: string;
}
export declare const ForEach = "ForEach";
export declare function isForEach(item: unknown): item is ForEach;
export interface FullTextSearch extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'FullTextSearch';
    name: QueryId;
    options?: MapLiteral;
    query: Literal;
}
export declare const FullTextSearch = "FullTextSearch";
export declare function isFullTextSearch(item: unknown): item is FullTextSearch;
export interface GenericDefBody extends langium.AstNode {
    readonly $container: AgentDefinition;
    readonly $type: 'GenericDefBody';
    attributes: Array<GenericPropertyDef>;
}
export declare const GenericDefBody = "GenericDefBody";
export declare function isGenericDefBody(item: unknown): item is GenericDefBody;
export interface GenericPropertyDef extends langium.AstNode {
    readonly $container: GenericDefBody;
    readonly $type: 'GenericPropertyDef';
    name: string;
    value: Literal;
}
export declare const GenericPropertyDef = "GenericPropertyDef";
export declare function isGenericPropertyDef(item: unknown): item is GenericPropertyDef;
export interface GlossaryEntryDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'GlossaryEntryDefinition';
    body?: MapLiteral;
    glos?: AgentXtraSpec;
    name: Ref;
}
export declare const GlossaryEntryDefinition = "GlossaryEntryDefinition";
export declare function isGlossaryEntryDefinition(item: unknown): item is GlossaryEntryDefinition;
export interface Group extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'Group';
    ge: Expr;
}
export declare const Group = "Group";
export declare function isGroup(item: unknown): item is Group;
export interface Handler extends langium.AstNode {
    readonly $container: CatchSpec;
    readonly $type: 'Handler';
    except: 'error' | 'not_found';
    stmt: Statement;
}
export declare const Handler = "Handler";
export declare function isHandler(item: unknown): item is Handler;
export interface If extends langium.AstNode {
    readonly $container: DirectiveDefinition | Pattern | ScenarioDefinition;
    readonly $type: 'If';
    cond: Expr;
    else?: Else;
    statements: Array<Statement>;
}
export declare const If = "If";
export declare function isIf(item: unknown): item is If;
export interface Import extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'Import';
    name: string;
    path: string;
}
export declare const Import = "Import";
export declare function isImport(item: unknown): item is Import;
export interface JoinSpec extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'JoinSpec';
    lhs: QueryId;
    name: QualifiedName;
    op?: SqlComparisonOpr;
    rhs: Ref;
    type: JoinType;
}
export declare const JoinSpec = "JoinSpec";
export declare function isJoinSpec(item: unknown): item is JoinSpec;
export interface KvPair extends langium.AstNode {
    readonly $container: KvPairs;
    readonly $type: 'KvPair';
    key?: string;
    value: Literal;
}
export declare const KvPair = "KvPair";
export declare function isKvPair(item: unknown): item is KvPair;
export interface KvPairs extends langium.AstNode {
    readonly $container: PropertyDefinition;
    readonly $type: 'KvPairs';
    pairs: Array<KvPair>;
}
export declare const KvPairs = "KvPairs";
export declare function isKvPairs(item: unknown): item is KvPairs;
export interface Literal extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | CrudMap | FnCall | FullTextSearch | GenericPropertyDef | Group | If | KvPair | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'Literal';
    array?: ArrayLiteral;
    asyncFnCall?: AsyncFnCall;
    bool?: Boolean;
    fnCall?: FnCall;
    id?: string;
    map?: MapLiteral;
    num?: Decimal;
    ref?: Ref;
    str?: string;
}
export declare const Literal = "Literal";
export declare function isLiteral(item: unknown): item is Literal;
export interface MapEntry extends langium.AstNode {
    readonly $container: MapLiteral;
    readonly $type: 'MapEntry';
    key: MapKey;
    value: Expr;
}
export declare const MapEntry = "MapEntry";
export declare function isMapEntry(item: unknown): item is MapEntry;
export interface MapKey extends langium.AstNode {
    readonly $container: MapEntry;
    readonly $type: 'MapKey';
    bool?: Boolean;
    num?: Decimal;
    str?: string;
}
export declare const MapKey = "MapKey";
export declare function isMapKey(item: unknown): item is MapKey;
export interface MapLiteral extends langium.AstNode {
    readonly $container: DirectiveDefinition | FullTextSearch | GlossaryEntryDefinition | Literal | MetaDefinition | ScenarioDefinition;
    readonly $type: 'MapLiteral';
    entries: Array<MapEntry>;
}
export declare const MapLiteral = "MapLiteral";
export declare function isMapLiteral(item: unknown): item is MapLiteral;
export interface MetaDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'MetaDefinition';
    spec: MapLiteral;
}
export declare const MetaDefinition = "MetaDefinition";
export declare function isMetaDefinition(item: unknown): item is MetaDefinition;
export interface ModuleDefinition extends langium.AstNode {
    readonly $type: 'ModuleDefinition';
    defs: Array<Definition>;
    imports: Array<Import>;
    name: QualifiedName;
}
export declare const ModuleDefinition = "ModuleDefinition";
export declare function isModuleDefinition(item: unknown): item is ModuleDefinition;
export interface NegExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'NegExpr';
    ne: Expr;
}
export declare const NegExpr = "NegExpr";
export declare function isNegExpr(item: unknown): item is NegExpr;
export interface NodeDefinition extends langium.AstNode {
    readonly $container: RelNodes;
    readonly $type: 'NodeDefinition';
    alias?: string;
    name: QualifiedName;
}
export declare const NodeDefinition = "NodeDefinition";
export declare function isNodeDefinition(item: unknown): item is NodeDefinition;
export interface NotExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'NotExpr';
    ne: Expr;
}
export declare const NotExpr = "NotExpr";
export declare function isNotExpr(item: unknown): item is NotExpr;
export interface OneOfSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'OneOfSpec';
    ref: Ref;
}
export declare const OneOfSpec = "OneOfSpec";
export declare function isOneOfSpec(item: unknown): item is OneOfSpec;
export interface Pattern extends langium.AstNode {
    readonly $container: Delete | ForEach | Purge | RelationshipPattern | Return | Statement;
    readonly $type: 'Pattern';
    crudMap?: CrudMap;
    delete?: Delete;
    expr?: Expr;
    forEach?: ForEach;
    fullTextSearch?: FullTextSearch;
    if?: If;
    purge?: Purge;
    return?: Return;
}
export declare const Pattern = "Pattern";
export declare function isPattern(item: unknown): item is Pattern;
export interface PrePostTriggerDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'PrePostTriggerDefinition';
    after?: AfterTriggerDefinition;
    before?: BeforeTriggerDefinition;
}
export declare const PrePostTriggerDefinition = "PrePostTriggerDefinition";
export declare function isPrePostTriggerDefinition(item: unknown): item is PrePostTriggerDefinition;
export interface PropertyDefinition extends langium.AstNode {
    readonly $container: AttributeDefinition | CrudMapBody | RelationshipDefinition;
    readonly $type: 'PropertyDefinition';
    name: TaggedId;
    value?: KvPairs;
}
export declare const PropertyDefinition = "PropertyDefinition";
export declare function isPropertyDefinition(item: unknown): item is PropertyDefinition;
export interface PublicAgentDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicAgentDefinition';
    def: AgentDefinition;
}
export declare const PublicAgentDefinition = "PublicAgentDefinition";
export declare function isPublicAgentDefinition(item: unknown): item is PublicAgentDefinition;
export interface PublicEventDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicEventDefinition';
    def: EventDefinition;
}
export declare const PublicEventDefinition = "PublicEventDefinition";
export declare function isPublicEventDefinition(item: unknown): item is PublicEventDefinition;
export interface PublicWorkflowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicWorkflowDefinition';
    def: WorkflowDefinition;
}
export declare const PublicWorkflowDefinition = "PublicWorkflowDefinition";
export declare function isPublicWorkflowDefinition(item: unknown): item is PublicWorkflowDefinition;
export interface Purge extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Purge';
    pattern: Pattern;
}
export declare const Purge = "Purge";
export declare function isPurge(item: unknown): item is Purge;
export interface RbacAllowSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacAllowSpec';
    oprs: Array<RbacOpr>;
}
export declare const RbacAllowSpec = "RbacAllowSpec";
export declare function isRbacAllowSpec(item: unknown): item is RbacAllowSpec;
export interface RbacExpressionSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacExpressionSpec';
    lhs: Ref;
    rhs: Ref;
}
export declare const RbacExpressionSpec = "RbacExpressionSpec";
export declare function isRbacExpressionSpec(item: unknown): item is RbacExpressionSpec;
export interface RbacOpr extends langium.AstNode {
    readonly $container: RbacAllowSpec;
    readonly $type: 'RbacOpr';
    value: 'create' | 'delete' | 'read' | 'update';
}
export declare const RbacOpr = "RbacOpr";
export declare function isRbacOpr(item: unknown): item is RbacOpr;
export interface RbacRolesSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacRolesSpec';
    roles: Array<'*' | string>;
}
export declare const RbacRolesSpec = "RbacRolesSpec";
export declare function isRbacRolesSpec(item: unknown): item is RbacRolesSpec;
export interface RbacSpecDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'RbacSpecDefinition';
    specEntries: Array<RbacSpecEntries>;
}
export declare const RbacSpecDefinition = "RbacSpecDefinition";
export declare function isRbacSpecDefinition(item: unknown): item is RbacSpecDefinition;
export interface RbacSpecEntries extends langium.AstNode {
    readonly $container: RbacSpecDefinition;
    readonly $type: 'RbacSpecEntries';
    entries: Array<RbacSpecEntry>;
}
export declare const RbacSpecEntries = "RbacSpecEntries";
export declare function isRbacSpecEntries(item: unknown): item is RbacSpecEntries;
export interface RbacSpecEntry extends langium.AstNode {
    readonly $container: RbacSpecEntries;
    readonly $type: 'RbacSpecEntry';
    allow?: RbacAllowSpec;
    expr?: RbacExpressionSpec;
    role?: RbacRolesSpec;
}
export declare const RbacSpecEntry = "RbacSpecEntry";
export declare function isRbacSpecEntry(item: unknown): item is RbacSpecEntry;
export interface RecordDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RecordDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}
export declare const RecordDefinition = "RecordDefinition";
export declare function isRecordDefinition(item: unknown): item is RecordDefinition;
export interface RecordExtraDefinition extends langium.AstNode {
    readonly $container: RecordSchemaDefinition;
    readonly $type: 'RecordExtraDefinition';
    actions?: EntityActionsDefinitions;
    meta?: MetaDefinition;
    prePost?: PrePostTriggerDefinition;
    rbacSpec?: RbacSpecDefinition;
    uq?: CompositeUniqueDefinition;
}
export declare const RecordExtraDefinition = "RecordExtraDefinition";
export declare function isRecordExtraDefinition(item: unknown): item is RecordExtraDefinition;
export interface RecordSchemaDefinition extends langium.AstNode {
    readonly $container: EntityDefinition | EventDefinition | RecordDefinition | RelationshipDefinition;
    readonly $type: 'RecordSchemaDefinition';
    attributes: Array<AttributeDefinition>;
    extras: Array<RecordExtraDefinition>;
}
export declare const RecordSchemaDefinition = "RecordSchemaDefinition";
export declare function isRecordSchemaDefinition(item: unknown): item is RecordSchemaDefinition;
export interface RefSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'RefSpec';
    ref: QualifiedName;
    type?: QualifiedName;
}
export declare const RefSpec = "RefSpec";
export declare function isRefSpec(item: unknown): item is RefSpec;
export interface RelationshipDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RelationshipDefinition';
    name: QualifiedName;
    nodes: RelNodes;
    properties: Array<PropertyDefinition>;
    schema?: RecordSchemaDefinition;
    type: 'between' | 'contains';
}
export declare const RelationshipDefinition = "RelationshipDefinition";
export declare function isRelationshipDefinition(item: unknown): item is RelationshipDefinition;
export interface RelationshipPattern extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'RelationshipPattern';
    name: QualifiedName;
    pattern: Pattern;
}
export declare const RelationshipPattern = "RelationshipPattern";
export declare function isRelationshipPattern(item: unknown): item is RelationshipPattern;
export interface RelNodes extends langium.AstNode {
    readonly $container: RelationshipDefinition;
    readonly $type: 'RelNodes';
    node1: NodeDefinition;
    node2: NodeDefinition;
}
export declare const RelNodes = "RelNodes";
export declare function isRelNodes(item: unknown): item is RelNodes;
export interface ResolverDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'ResolverDefinition';
    methods: Array<ResolverMethodSpec>;
    name: GenericName;
    paths: Array<GenericName>;
}
export declare const ResolverDefinition = "ResolverDefinition";
export declare function isResolverDefinition(item: unknown): item is ResolverDefinition;
export interface ResolverFnName extends langium.AstNode {
    readonly $container: ResolverMethodSpec;
    readonly $type: 'ResolverFnName';
    name: Ref | string;
}
export declare const ResolverFnName = "ResolverFnName";
export declare function isResolverFnName(item: unknown): item is ResolverFnName;
export interface ResolverMethodName extends langium.AstNode {
    readonly $container: ResolverMethodSpec;
    readonly $type: 'ResolverMethodName';
    name: 'commitTransaction' | 'create' | 'delete' | 'onSubscription' | 'query' | 'rollbackTransaction' | 'startTransaction' | 'subscribe' | 'update' | 'upsert';
}
export declare const ResolverMethodName = "ResolverMethodName";
export declare function isResolverMethodName(item: unknown): item is ResolverMethodName;
export interface ResolverMethodSpec extends langium.AstNode {
    readonly $container: ResolverDefinition;
    readonly $type: 'ResolverMethodSpec';
    fn: ResolverFnName;
    key: ResolverMethodName;
}
export declare const ResolverMethodSpec = "ResolverMethodSpec";
export declare function isResolverMethodSpec(item: unknown): item is ResolverMethodSpec;
export interface RetryDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RetryDefinition';
    attempts?: Decimal;
    backoff?: BackoffSpec;
    name: string;
}
export declare const RetryDefinition = "RetryDefinition";
export declare function isRetryDefinition(item: unknown): item is RetryDefinition;
export interface Return extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Return';
    pattern: Pattern;
}
export declare const Return = "Return";
export declare function isReturn(item: unknown): item is Return;
export interface RuntimeHint extends langium.AstNode {
    readonly $container: Statement;
    readonly $type: 'RuntimeHint';
    aliasSpec?: AliasSpec;
    catchSpec?: CatchSpec;
    thenSpec?: ThenSpec;
}
export declare const RuntimeHint = "RuntimeHint";
export declare function isRuntimeHint(item: unknown): item is RuntimeHint;
export interface ScenarioDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'ScenarioDefinition';
    body?: MapLiteral;
    name: Ref;
    scn?: If;
}
export declare const ScenarioDefinition = "ScenarioDefinition";
export declare function isScenarioDefinition(item: unknown): item is ScenarioDefinition;
export interface SelectIntoEntry extends langium.AstNode {
    readonly $container: SelectIntoSpec;
    readonly $type: 'SelectIntoEntry';
    alias: string;
    attribute: Ref;
}
export declare const SelectIntoEntry = "SelectIntoEntry";
export declare function isSelectIntoEntry(item: unknown): item is SelectIntoEntry;
export interface SelectIntoSpec extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'SelectIntoSpec';
    entries: Array<SelectIntoEntry>;
}
export declare const SelectIntoSpec = "SelectIntoSpec";
export declare function isSelectIntoSpec(item: unknown): item is SelectIntoSpec;
export interface SetAttribute extends langium.AstNode {
    readonly $container: BackoffSpec | CrudMapBody;
    readonly $type: 'SetAttribute';
    name: QueryId;
    op?: SqlComparisonOpr;
    value: AttributeValueExpression;
}
export declare const SetAttribute = "SetAttribute";
export declare function isSetAttribute(item: unknown): item is SetAttribute;
export interface StandaloneStatement extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'StandaloneStatement';
    stmt: Statement;
}
export declare const StandaloneStatement = "StandaloneStatement";
export declare function isStandaloneStatement(item: unknown): item is StandaloneStatement;
export interface Statement extends langium.AstNode {
    readonly $container: ArrayLiteral | CaseEntry | Else | ForEach | Handler | If | StandaloneStatement | ThenSpec | WorkflowDefinition;
    readonly $type: 'Statement';
    hints: Array<RuntimeHint>;
    pattern: Pattern;
}
export declare const Statement = "Statement";
export declare function isStatement(item: unknown): item is Statement;
export interface ThenSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'ThenSpec';
    statements: Array<Statement>;
}
export declare const ThenSpec = "ThenSpec";
export declare function isThenSpec(item: unknown): item is ThenSpec;
export interface TriggerDefinition extends langium.AstNode {
    readonly $container: AfterTriggerDefinition | BeforeTriggerDefinition;
    readonly $type: 'TriggerDefinition';
    entries: Array<TriggerEntry>;
}
export declare const TriggerDefinition = "TriggerDefinition";
export declare function isTriggerDefinition(item: unknown): item is TriggerDefinition;
export interface TriggerEntry extends langium.AstNode {
    readonly $container: TriggerDefinition;
    readonly $type: 'TriggerEntry';
    async?: '@async';
    event: string;
    on: 'create' | 'delete' | 'update';
}
export declare const TriggerEntry = "TriggerEntry";
export declare function isTriggerEntry(item: unknown): item is TriggerEntry;
export interface WorkflowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicWorkflowDefinition;
    readonly $type: 'WorkflowDefinition';
    header?: WorkflowHeader;
    name?: string;
    statements: Array<Statement>;
}
export declare const WorkflowDefinition = "WorkflowDefinition";
export declare function isWorkflowDefinition(item: unknown): item is WorkflowDefinition;
export interface WorkflowHeader extends langium.AstNode {
    readonly $container: WorkflowDefinition;
    readonly $type: 'WorkflowHeader';
    name: QualifiedName;
    prefix: WorkflowHeaderPrefix;
    tag: WorkflowHeaderTag;
}
export declare const WorkflowHeader = "WorkflowHeader";
export declare function isWorkflowHeader(item: unknown): item is WorkflowHeader;
export type AgentlangAstType = {
    ActionEntry: ActionEntry;
    AfterTriggerDefinition: AfterTriggerDefinition;
    AgentDefinition: AgentDefinition;
    AgentXtraAttribute: AgentXtraAttribute;
    AgentXtraSpec: AgentXtraSpec;
    AliasSpec: AliasSpec;
    ArrayLiteral: ArrayLiteral;
    AsyncFnCall: AsyncFnCall;
    AttributeDefinition: AttributeDefinition;
    AttributeValueExpression: AttributeValueExpression;
    BackoffSpec: BackoffSpec;
    BeforeTriggerDefinition: BeforeTriggerDefinition;
    BinExpr: BinExpr;
    CaseEntry: CaseEntry;
    CatchSpec: CatchSpec;
    CompositeUniqueDefinition: CompositeUniqueDefinition;
    ConditionalFlowStep: ConditionalFlowStep;
    CrudMap: CrudMap;
    CrudMapBody: CrudMapBody;
    DecisionDefBody: DecisionDefBody;
    DecisionDefinition: DecisionDefinition;
    Definition: Definition;
    Delete: Delete;
    DirectiveDefinition: DirectiveDefinition;
    Else: Else;
    EntityActionsDefinitions: EntityActionsDefinitions;
    EntityDefinition: EntityDefinition;
    EnumSpec: EnumSpec;
    EventDefinition: EventDefinition;
    Expr: Expr;
    ExtendsClause: ExtendsClause;
    FlowDefBody: FlowDefBody;
    FlowDefinition: FlowDefinition;
    FlowEntry: FlowEntry;
    FlowStepSpec: FlowStepSpec;
    FnCall: FnCall;
    ForEach: ForEach;
    FullTextSearch: FullTextSearch;
    GenericDefBody: GenericDefBody;
    GenericPropertyDef: GenericPropertyDef;
    GlossaryEntryDefinition: GlossaryEntryDefinition;
    Group: Group;
    Handler: Handler;
    If: If;
    Import: Import;
    JoinSpec: JoinSpec;
    KvPair: KvPair;
    KvPairs: KvPairs;
    Literal: Literal;
    MapEntry: MapEntry;
    MapKey: MapKey;
    MapLiteral: MapLiteral;
    MetaDefinition: MetaDefinition;
    ModuleDefinition: ModuleDefinition;
    NegExpr: NegExpr;
    NodeDefinition: NodeDefinition;
    NotExpr: NotExpr;
    OneOfSpec: OneOfSpec;
    Pattern: Pattern;
    PrePostTriggerDefinition: PrePostTriggerDefinition;
    PrimExpr: PrimExpr;
    PropertyDefinition: PropertyDefinition;
    PublicAgentDefinition: PublicAgentDefinition;
    PublicEventDefinition: PublicEventDefinition;
    PublicWorkflowDefinition: PublicWorkflowDefinition;
    Purge: Purge;
    RbacAllowSpec: RbacAllowSpec;
    RbacExpressionSpec: RbacExpressionSpec;
    RbacOpr: RbacOpr;
    RbacRolesSpec: RbacRolesSpec;
    RbacSpecDefinition: RbacSpecDefinition;
    RbacSpecEntries: RbacSpecEntries;
    RbacSpecEntry: RbacSpecEntry;
    RecordDefinition: RecordDefinition;
    RecordExtraDefinition: RecordExtraDefinition;
    RecordSchemaDefinition: RecordSchemaDefinition;
    RefSpec: RefSpec;
    RelNodes: RelNodes;
    RelationshipDefinition: RelationshipDefinition;
    RelationshipPattern: RelationshipPattern;
    ResolverDefinition: ResolverDefinition;
    ResolverFnName: ResolverFnName;
    ResolverMethodName: ResolverMethodName;
    ResolverMethodSpec: ResolverMethodSpec;
    RetryDefinition: RetryDefinition;
    Return: Return;
    RuntimeHint: RuntimeHint;
    ScenarioDefinition: ScenarioDefinition;
    SchemaDefinition: SchemaDefinition;
    SelectIntoEntry: SelectIntoEntry;
    SelectIntoSpec: SelectIntoSpec;
    SetAttribute: SetAttribute;
    StandaloneStatement: StandaloneStatement;
    Statement: Statement;
    ThenSpec: ThenSpec;
    TriggerDefinition: TriggerDefinition;
    TriggerEntry: TriggerEntry;
    WorkflowDefinition: WorkflowDefinition;
    WorkflowHeader: WorkflowHeader;
};
export declare class AgentlangAstReflection extends langium.AbstractAstReflection {
    getAllTypes(): string[];
    protected computeIsSubtype(subtype: string, supertype: string): boolean;
    getReferenceType(refInfo: langium.ReferenceInfo): string;
    getTypeMetaData(type: string): langium.TypeMetaData;
}
export declare const reflection: AgentlangAstReflection;
//# sourceMappingURL=ast.d.ts.map