/******************************************************************************
 * This file was generated by langium-cli 4.2.0.
 * DO NOT EDIT MANUALLY!
 ******************************************************************************/
import * as langium from 'langium';
export declare const DomainLangTerminals: {
    WS: RegExp;
    ID: RegExp;
    STRING: RegExp;
    ML_COMMENT: RegExp;
    SL_COMMENT: RegExp;
};
export type DomainLangTerminalNames = keyof typeof DomainLangTerminals;
export type DomainLangKeywordNames = "," | "->" | "." | ":" | "<-" | "<->" | "=" | "><" | "ACL" | "AntiCorruptionLayer" | "BBoM" | "BigBallOfMud" | "BoundedContext" | "C" | "CF" | "Classification" | "Conformist" | "ContextMap" | "Customer" | "Decision" | "Domain" | "DomainMap" | "Import" | "Metadata" | "Namespace" | "OHS" | "OpenHostService" | "P" | "PL" | "Partnership" | "Policy" | "PublishedLanguage" | "Rule" | "S" | "SK" | "SW" | "SeparateWays" | "SharedKernel" | "Supplier" | "Team" | "Term" | "[" | "]" | "aka" | "archetype" | "as" | "bc" | "businessModel" | "by" | "classification" | "cmap" | "contains" | "decision" | "decisions" | "description" | "dmap" | "dom" | "evolution" | "examples" | "for" | "glossary" | "import" | "in" | "integrations" | "is" | "meta" | "metadata" | "ns" | "policy" | "relationships" | "rule" | "rules" | "synonyms" | "team" | "term" | "terminology" | "this" | "type" | "vision" | "{" | "}";
export type DomainLangTokenNames = DomainLangTerminalNames | DomainLangKeywordNames;
/**
 * Decisions, Policies, and Business Rules.
 * All types are interchangeable - use what reads best for your domain.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)
 */
export type AbstractDecision = BusinessRule | Decision | Policy;
export declare const AbstractDecision: {
    readonly $type: "AbstractDecision";
};
export declare function isAbstractDecision(item: unknown): item is AbstractDecision;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface AntiCorruptionLayer extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'AntiCorruptionLayer';
}
export declare const AntiCorruptionLayer: {
    readonly $type: "AntiCorruptionLayer";
};
export declare function isAntiCorruptionLayer(item: unknown): item is AntiCorruptionLayer;
/**
 * Assignment operators - flexible syntax.
 */
export type Assignment = ':' | '=' | 'is';
export declare function isAssignment(item: unknown): item is Assignment;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface BigBallOfMud extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'BigBallOfMud';
}
export declare const BigBallOfMud: {
    readonly $type: "BigBallOfMud";
};
export declare function isBigBallOfMud(item: unknown): item is BigBallOfMud;
/**
 * Bounded Context - A boundary within which a domain model is defined.
 * Central pattern in DDD for managing complexity and team boundaries.
 * Belongs to exactly ONE domain (fundamental DDD principle).
 * Body properties can appear in any order. Validation enforces at-most-once constraint.
 * The `classification` property indicates strategic importance per Bounded Context Canvas.
 * The `evolution` property indicates maturity stage per Wardley Maps/BC Canvas.
 * The `archetype` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)
 */
export interface BoundedContext extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'Assignment' | 'BoundedContext';
    archetype?: langium.Reference<Classification>;
    businessModel?: langium.Reference<Classification>;
    classification: Array<langium.Reference<Classification>>;
    decisions: Array<AbstractDecision>;
    description?: string;
    domain?: langium.Reference<Domain>;
    evolution?: langium.Reference<Classification>;
    metadata: Array<MetadataEntry>;
    name: string;
    relationships: Array<Relationship>;
    team: Array<langium.Reference<Team>>;
    terminology: Array<DomainTerm>;
}
export declare const BoundedContext: {
    readonly $type: "BoundedContext";
    readonly archetype: "archetype";
    readonly businessModel: "businessModel";
    readonly classification: "classification";
    readonly decisions: "decisions";
    readonly description: "description";
    readonly domain: "domain";
    readonly evolution: "evolution";
    readonly metadata: "metadata";
    readonly name: "name";
    readonly relationships: "relationships";
    readonly team: "team";
    readonly terminology: "terminology";
};
export declare function isBoundedContext(item: unknown): item is BoundedContext;
/**
 * Context reference - can be 'this' (self-reference) or a qualified name.
 */
export interface BoundedContextRef extends langium.AstNode {
    readonly $type: 'BoundedContextRef' | 'ThisRef';
    link?: langium.Reference<BoundedContext>;
}
export declare const BoundedContextRef: {
    readonly $type: "BoundedContextRef";
    readonly link: "link";
};
export declare function isBoundedContextRef(item: unknown): item is BoundedContextRef;
export interface BusinessRule extends langium.AstNode {
    readonly $container: BoundedContext;
    readonly $type: 'Assignment' | 'BusinessRule';
    classification: langium.Reference<Classification>;
    name: string;
    value: string;
}
export declare const BusinessRule: {
    readonly $type: "BusinessRule";
    readonly classification: "classification";
    readonly name: "name";
    readonly value: "value";
};
export declare function isBusinessRule(item: unknown): item is BusinessRule;
/**
 * Classification - Reusable label for categorizing elements.
 * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)
 */
export interface Classification extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'Classification';
    name: string;
}
export declare const Classification: {
    readonly $type: "Classification";
    readonly name: "name";
};
export declare function isClassification(item: unknown): item is Classification;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Conformist extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Conformist';
}
export declare const Conformist: {
    readonly $type: "Conformist";
};
export declare function isConformist(item: unknown): item is Conformist;
export type Container = Model | NamespaceDeclaration;
export declare const Container: {
    readonly $type: "Container";
};
export declare function isContainer(item: unknown): item is Container;
/**
 * Context Map - Visualizes relationships between Bounded Contexts.
 * Shows integration patterns and team interactions.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)
 */
export interface ContextMap extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'ContextMap';
    boundedContexts: Array<langium.MultiReference<BoundedContext>>;
    name: string;
    relationships: Array<Relationship>;
}
export declare const ContextMap: {
    readonly $type: "ContextMap";
    readonly boundedContexts: "boundedContexts";
    readonly name: "name";
    readonly relationships: "relationships";
};
export declare function isContextMap(item: unknown): item is ContextMap;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Customer extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Customer';
}
export declare const Customer: {
    readonly $type: "Customer";
};
export declare function isCustomer(item: unknown): item is Customer;
export interface Decision extends langium.AstNode {
    readonly $container: BoundedContext;
    readonly $type: 'Assignment' | 'Decision';
    classification: langium.Reference<Classification>;
    name: string;
    value: string;
}
export declare const Decision: {
    readonly $type: "Decision";
    readonly classification: "classification";
    readonly name: "name";
    readonly value: "value";
};
export declare function isDecision(item: unknown): item is Decision;
/**
 * Directional relationship arrows.
 *
 * Arrow semantics:
 *   ->   Upstream to downstream (left provides, right consumes)
 *   <-   Downstream to upstream (right provides, left consumes)
 *   <->  Bidirectional (mutual data flow with explicit patterns)
 */
export type DirectionalArrow = '->' | '<-' | '<->';
export declare function isDirectionalArrow(item: unknown): item is DirectionalArrow;
/**
 * Directional relationship - upstream/downstream with optional side patterns.
 *
 * Examples:
 *   Orders [OHS] -> [CF] Payments
 *   Orders [S] -> [C] Payments
 *   Orders -> Payments
 *   Orders [OHS] <-> [CF] Payments
 */
export interface DirectionalRelationship extends langium.AstNode {
    readonly $container: BoundedContext | ContextMap;
    readonly $type: 'DirectionalRelationship';
    arrow: DirectionalArrow;
    left: BoundedContextRef;
    leftPatterns: Array<SidePattern>;
    right: BoundedContextRef;
    rightPatterns: Array<SidePattern>;
}
export declare const DirectionalRelationship: {
    readonly $type: "DirectionalRelationship";
    readonly arrow: "arrow";
    readonly left: "left";
    readonly leftPatterns: "leftPatterns";
    readonly right: "right";
    readonly rightPatterns: "rightPatterns";
};
export declare function isDirectionalRelationship(item: unknown): item is DirectionalRelationship;
/**
 * Domain - A sphere of knowledge or activity in DDD.
 * Can be nested via `in` to show subdomain hierarchy.
 * The `type` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.
 * Body is optional - allows header-only Domain definitions.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)
 */
export interface Domain extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'Assignment' | 'Domain';
    description?: string;
    name: string;
    parent?: langium.Reference<Domain>;
    type?: langium.Reference<Classification>;
    vision?: string;
}
export declare const Domain: {
    readonly $type: "Domain";
    readonly description: "description";
    readonly name: "name";
    readonly parent: "parent";
    readonly type: "type";
    readonly vision: "vision";
};
export declare function isDomain(item: unknown): item is Domain;
/**
 * Domain Map - Visualizes relationships between Domains.
 * Shows high-level domain organization and subdomain structure.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)
 */
export interface DomainMap extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'DomainMap';
    domains: Array<langium.MultiReference<Domain>>;
    name: string;
}
export declare const DomainMap: {
    readonly $type: "DomainMap";
    readonly domains: "domains";
    readonly name: "name";
};
export declare function isDomainMap(item: unknown): item is DomainMap;
/**
 * Domain Terminology - Ubiquitous language terms with definitions.
 * Supports synonyms and examples for richer glossaries.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)
 */
export interface DomainTerm extends langium.AstNode {
    readonly $container: BoundedContext;
    readonly $type: 'Assignment' | 'DomainTerm';
    examples: Array<string>;
    meaning?: string;
    name: string;
    synonyms: Array<string>;
}
export declare const DomainTerm: {
    readonly $type: "DomainTerm";
    readonly examples: "examples";
    readonly meaning: "meaning";
    readonly name: "name";
    readonly synonyms: "synonyms";
};
export declare function isDomainTerm(item: unknown): item is DomainTerm;
/**
 * Import Statement - Manifest-centric import system per PRS-010.
 *
 * Simplified syntax where import statements use short specifiers:
 *   - External dependencies (from manifest): import "core" as Core
 *   - Local files: import "./shared/types.dlang"
 *   - Workspace-relative: import "~/contexts/sales.dlang"
 *
 * All resolution details (source, version, integrity) live in model.yaml manifest.
 * Named imports and inline integrity checks have been removed per PRS-010.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)
 */
export interface ImportStatement extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'ImportStatement';
    alias?: string;
    uri: string;
}
export declare const ImportStatement: {
    readonly $type: "ImportStatement";
    readonly alias: "alias";
    readonly uri: "uri";
};
export declare function isImportStatement(item: unknown): item is ImportStatement;
/**
 * Metadata - Defines a key that can be used in metadata blocks.
 * Examples: Language, Framework, Database, Repository.
 * Can be defined locally or imported from stdlib.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)
 */
export interface Metadata extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'Metadata';
    name: string;
}
export declare const Metadata: {
    readonly $type: "Metadata";
    readonly name: "name";
};
export declare function isMetadata(item: unknown): item is Metadata;
export interface MetadataEntry extends langium.AstNode {
    readonly $container: BoundedContext;
    readonly $type: 'Assignment' | 'MetadataEntry';
    key: langium.Reference<Metadata>;
    value: string;
}
export declare const MetadataEntry: {
    readonly $type: "MetadataEntry";
    readonly key: "key";
    readonly value: "value";
};
export declare function isMetadataEntry(item: unknown): item is MetadataEntry;
/**
 * Root AST node - aggregates all top-level DDD elements.
 * Produces the entry point for parsing .dlang files.
 */
export interface Model extends langium.AstNode {
    readonly $type: 'Model';
    children: Array<StructureElement>;
    imports: Array<ImportStatement>;
}
export declare const Model: {
    readonly $type: "Model";
    readonly children: "children";
    readonly imports: "imports";
};
export declare function isModel(item: unknown): item is Model;
/**
 * Namespace Declaration - Hierarchical namespacing for organizing models.
 * Combines package modularity with group-style nesting.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)
 */
export interface NamespaceDeclaration extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'NamespaceDeclaration';
    children: Array<StructureElement>;
    name: QualifiedName;
}
export declare const NamespaceDeclaration: {
    readonly $type: "NamespaceDeclaration";
    readonly children: "children";
    readonly name: "name";
};
export declare function isNamespaceDeclaration(item: unknown): item is NamespaceDeclaration;
/**
 * Union of mapping constructs for visualizing architecture.
 */
export type ObjectMap = ContextMap | DomainMap;
export declare const ObjectMap: {
    readonly $type: "ObjectMap";
};
export declare function isObjectMap(item: unknown): item is ObjectMap;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface OpenHostService extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'OpenHostService';
}
export declare const OpenHostService: {
    readonly $type: "OpenHostService";
};
export declare function isOpenHostService(item: unknown): item is OpenHostService;
/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface Partnership extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'Partnership';
}
export declare const Partnership: {
    readonly $type: "Partnership";
};
export declare function isPartnership(item: unknown): item is Partnership;
export interface Policy extends langium.AstNode {
    readonly $container: BoundedContext;
    readonly $type: 'Assignment' | 'Policy';
    classification: langium.Reference<Classification>;
    name: string;
    value: string;
}
export declare const Policy: {
    readonly $type: "Policy";
    readonly classification: "classification";
    readonly name: "name";
    readonly value: "value";
};
export declare function isPolicy(item: unknown): item is Policy;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface PublishedLanguage extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'PublishedLanguage';
}
export declare const PublishedLanguage: {
    readonly $type: "PublishedLanguage";
};
export declare function isPublishedLanguage(item: unknown): item is PublishedLanguage;
/**
 * Qualified Name - Hierarchical namespacing with dots.
 */
export type QualifiedName = string;
export declare function isQualifiedName(item: unknown): item is QualifiedName;
/**
 * Relationship - Connection between two Bounded Contexts.
 * Uses entity–relationship–entity structure where the relationship expression
 * (type, arrow, side annotations) sits between the two entity references.
 *
 * Forms:
 *   Directional: Orders [OHS] -> [CF] Payments
 *   Symmetric:   CardManagement [SK] AccountManagement
 *   Separate Ways arrow: Orders >< Payments
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)
 */
export type Relationship = DirectionalRelationship | SymmetricRelationship;
export declare const Relationship: {
    readonly $type: "Relationship";
};
export declare function isRelationship(item: unknown): item is Relationship;
/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface SeparateWays extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'SeparateWays';
}
export declare const SeparateWays: {
    readonly $type: "SeparateWays";
};
export declare function isSeparateWays(item: unknown): item is SeparateWays;
/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface SharedKernel extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'SharedKernel';
}
export declare const SharedKernel: {
    readonly $type: "SharedKernel";
};
export declare function isSharedKernel(item: unknown): item is SharedKernel;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export type SidePattern = AntiCorruptionLayer | BigBallOfMud | Conformist | Customer | OpenHostService | PublishedLanguage | Supplier;
export declare const SidePattern: {
    readonly $type: "SidePattern";
};
export declare function isSidePattern(item: unknown): item is SidePattern;
/**
 * Top-level elements that can appear in the model.
 * Unifies all major DDD constructs for flexible ordering.
 */
export type StructureElement = NamespaceDeclaration | ObjectMap | Type;
export declare const StructureElement: {
    readonly $type: "StructureElement";
};
export declare function isStructureElement(item: unknown): item is StructureElement;
/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Supplier extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Supplier';
}
export declare const Supplier: {
    readonly $type: "Supplier";
};
export declare function isSupplier(item: unknown): item is Supplier;
/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export type SymmetricPattern = Partnership | SeparateWays | SharedKernel;
export declare const SymmetricPattern: {
    readonly $type: "SymmetricPattern";
};
export declare function isSymmetricPattern(item: unknown): item is SymmetricPattern;
/**
 * Symmetric relationship - mutual pattern between two contexts, no directionality.
 *
 * Examples:
 *   CardManagement [SK] AccountManagement
 *   Orders [P] Payments
 *   Orders >< Payments
 *   Orders [SW] Payments
 */
export interface SymmetricRelationship extends langium.AstNode {
    readonly $container: BoundedContext | ContextMap;
    readonly $type: 'SymmetricRelationship';
    arrow?: '><';
    left: BoundedContextRef;
    pattern?: SymmetricPattern;
    right: BoundedContextRef;
}
export declare const SymmetricRelationship: {
    readonly $type: "SymmetricRelationship";
    readonly arrow: "arrow";
    readonly left: "left";
    readonly pattern: "pattern";
    readonly right: "right";
};
export declare function isSymmetricRelationship(item: unknown): item is SymmetricRelationship;
/**
 * Team - People responsible for a Bounded Context or Domain.
 * Represents organizational boundaries in DDD.
 *
 * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)
 */
export interface Team extends langium.AstNode {
    readonly $container: Model | NamespaceDeclaration;
    readonly $type: 'Team';
    name: string;
}
export declare const Team: {
    readonly $type: "Team";
    readonly name: "name";
};
export declare function isTeam(item: unknown): item is Team;
/**
 * Context reference - can be 'this' (self-reference) or a qualified name.
 */
export interface ThisRef extends BoundedContextRef {
    readonly $type: 'ThisRef';
}
export declare const ThisRef: {
    readonly $type: "ThisRef";
    readonly link: "link";
};
export declare function isThisRef(item: unknown): item is ThisRef;
/**
 * Union of all main DDD type constructs.
 */
export type Type = BoundedContext | Classification | Domain | Metadata | Team;
export declare const Type: {
    readonly $type: "Type";
};
export declare function isType(item: unknown): item is Type;
export type DomainLangAstType = {
    AbstractDecision: AbstractDecision;
    AntiCorruptionLayer: AntiCorruptionLayer;
    BigBallOfMud: BigBallOfMud;
    BoundedContext: BoundedContext;
    BoundedContextRef: BoundedContextRef;
    BusinessRule: BusinessRule;
    Classification: Classification;
    Conformist: Conformist;
    Container: Container;
    ContextMap: ContextMap;
    Customer: Customer;
    Decision: Decision;
    DirectionalRelationship: DirectionalRelationship;
    Domain: Domain;
    DomainMap: DomainMap;
    DomainTerm: DomainTerm;
    ImportStatement: ImportStatement;
    Metadata: Metadata;
    MetadataEntry: MetadataEntry;
    Model: Model;
    NamespaceDeclaration: NamespaceDeclaration;
    ObjectMap: ObjectMap;
    OpenHostService: OpenHostService;
    Partnership: Partnership;
    Policy: Policy;
    PublishedLanguage: PublishedLanguage;
    Relationship: Relationship;
    SeparateWays: SeparateWays;
    SharedKernel: SharedKernel;
    SidePattern: SidePattern;
    StructureElement: StructureElement;
    Supplier: Supplier;
    SymmetricPattern: SymmetricPattern;
    SymmetricRelationship: SymmetricRelationship;
    Team: Team;
    ThisRef: ThisRef;
    Type: Type;
};
export declare class DomainLangAstReflection extends langium.AbstractAstReflection {
    readonly types: {
        readonly AbstractDecision: {
            readonly name: "AbstractDecision";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly AntiCorruptionLayer: {
            readonly name: "AntiCorruptionLayer";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly BigBallOfMud: {
            readonly name: "BigBallOfMud";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly BoundedContext: {
            readonly name: "BoundedContext";
            readonly properties: {
                readonly archetype: {
                    readonly name: "archetype";
                    readonly referenceType: "Classification";
                };
                readonly businessModel: {
                    readonly name: "businessModel";
                    readonly referenceType: "Classification";
                };
                readonly classification: {
                    readonly name: "classification";
                    readonly defaultValue: [];
                    readonly referenceType: "Classification";
                };
                readonly decisions: {
                    readonly name: "decisions";
                    readonly defaultValue: [];
                };
                readonly description: {
                    readonly name: "description";
                };
                readonly domain: {
                    readonly name: "domain";
                    readonly referenceType: "Domain";
                };
                readonly evolution: {
                    readonly name: "evolution";
                    readonly referenceType: "Classification";
                };
                readonly metadata: {
                    readonly name: "metadata";
                    readonly defaultValue: [];
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly relationships: {
                    readonly name: "relationships";
                    readonly defaultValue: [];
                };
                readonly team: {
                    readonly name: "team";
                    readonly defaultValue: [];
                    readonly referenceType: "Team";
                };
                readonly terminology: {
                    readonly name: "terminology";
                    readonly defaultValue: [];
                };
            };
            readonly superTypes: ["Type"];
        };
        readonly BoundedContextRef: {
            readonly name: "BoundedContextRef";
            readonly properties: {
                readonly link: {
                    readonly name: "link";
                    readonly referenceType: "BoundedContext";
                };
            };
            readonly superTypes: [];
        };
        readonly BusinessRule: {
            readonly name: "BusinessRule";
            readonly properties: {
                readonly classification: {
                    readonly name: "classification";
                    readonly referenceType: "Classification";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly value: {
                    readonly name: "value";
                };
            };
            readonly superTypes: ["AbstractDecision"];
        };
        readonly Classification: {
            readonly name: "Classification";
            readonly properties: {
                readonly name: {
                    readonly name: "name";
                };
            };
            readonly superTypes: ["Type"];
        };
        readonly Conformist: {
            readonly name: "Conformist";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly Container: {
            readonly name: "Container";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly ContextMap: {
            readonly name: "ContextMap";
            readonly properties: {
                readonly boundedContexts: {
                    readonly name: "boundedContexts";
                    readonly defaultValue: [];
                    readonly referenceType: "BoundedContext";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly relationships: {
                    readonly name: "relationships";
                    readonly defaultValue: [];
                };
            };
            readonly superTypes: ["ObjectMap"];
        };
        readonly Customer: {
            readonly name: "Customer";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly Decision: {
            readonly name: "Decision";
            readonly properties: {
                readonly classification: {
                    readonly name: "classification";
                    readonly referenceType: "Classification";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly value: {
                    readonly name: "value";
                };
            };
            readonly superTypes: ["AbstractDecision"];
        };
        readonly DirectionalRelationship: {
            readonly name: "DirectionalRelationship";
            readonly properties: {
                readonly arrow: {
                    readonly name: "arrow";
                };
                readonly left: {
                    readonly name: "left";
                };
                readonly leftPatterns: {
                    readonly name: "leftPatterns";
                    readonly defaultValue: [];
                };
                readonly right: {
                    readonly name: "right";
                };
                readonly rightPatterns: {
                    readonly name: "rightPatterns";
                    readonly defaultValue: [];
                };
            };
            readonly superTypes: ["Relationship"];
        };
        readonly Domain: {
            readonly name: "Domain";
            readonly properties: {
                readonly description: {
                    readonly name: "description";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly parent: {
                    readonly name: "parent";
                    readonly referenceType: "Domain";
                };
                readonly type: {
                    readonly name: "type";
                    readonly referenceType: "Classification";
                };
                readonly vision: {
                    readonly name: "vision";
                };
            };
            readonly superTypes: ["Type"];
        };
        readonly DomainMap: {
            readonly name: "DomainMap";
            readonly properties: {
                readonly domains: {
                    readonly name: "domains";
                    readonly defaultValue: [];
                    readonly referenceType: "Domain";
                };
                readonly name: {
                    readonly name: "name";
                };
            };
            readonly superTypes: ["ObjectMap"];
        };
        readonly DomainTerm: {
            readonly name: "DomainTerm";
            readonly properties: {
                readonly examples: {
                    readonly name: "examples";
                    readonly defaultValue: [];
                };
                readonly meaning: {
                    readonly name: "meaning";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly synonyms: {
                    readonly name: "synonyms";
                    readonly defaultValue: [];
                };
            };
            readonly superTypes: [];
        };
        readonly ImportStatement: {
            readonly name: "ImportStatement";
            readonly properties: {
                readonly alias: {
                    readonly name: "alias";
                };
                readonly uri: {
                    readonly name: "uri";
                };
            };
            readonly superTypes: [];
        };
        readonly Metadata: {
            readonly name: "Metadata";
            readonly properties: {
                readonly name: {
                    readonly name: "name";
                };
            };
            readonly superTypes: ["Type"];
        };
        readonly MetadataEntry: {
            readonly name: "MetadataEntry";
            readonly properties: {
                readonly key: {
                    readonly name: "key";
                    readonly referenceType: "Metadata";
                };
                readonly value: {
                    readonly name: "value";
                };
            };
            readonly superTypes: [];
        };
        readonly Model: {
            readonly name: "Model";
            readonly properties: {
                readonly children: {
                    readonly name: "children";
                    readonly defaultValue: [];
                };
                readonly imports: {
                    readonly name: "imports";
                    readonly defaultValue: [];
                };
            };
            readonly superTypes: ["Container"];
        };
        readonly NamespaceDeclaration: {
            readonly name: "NamespaceDeclaration";
            readonly properties: {
                readonly children: {
                    readonly name: "children";
                    readonly defaultValue: [];
                };
                readonly name: {
                    readonly name: "name";
                };
            };
            readonly superTypes: ["Container", "StructureElement"];
        };
        readonly ObjectMap: {
            readonly name: "ObjectMap";
            readonly properties: {};
            readonly superTypes: ["StructureElement"];
        };
        readonly OpenHostService: {
            readonly name: "OpenHostService";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly Partnership: {
            readonly name: "Partnership";
            readonly properties: {};
            readonly superTypes: ["SymmetricPattern"];
        };
        readonly Policy: {
            readonly name: "Policy";
            readonly properties: {
                readonly classification: {
                    readonly name: "classification";
                    readonly referenceType: "Classification";
                };
                readonly name: {
                    readonly name: "name";
                };
                readonly value: {
                    readonly name: "value";
                };
            };
            readonly superTypes: ["AbstractDecision"];
        };
        readonly PublishedLanguage: {
            readonly name: "PublishedLanguage";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly Relationship: {
            readonly name: "Relationship";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly SeparateWays: {
            readonly name: "SeparateWays";
            readonly properties: {};
            readonly superTypes: ["SymmetricPattern"];
        };
        readonly SharedKernel: {
            readonly name: "SharedKernel";
            readonly properties: {};
            readonly superTypes: ["SymmetricPattern"];
        };
        readonly SidePattern: {
            readonly name: "SidePattern";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly StructureElement: {
            readonly name: "StructureElement";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly Supplier: {
            readonly name: "Supplier";
            readonly properties: {};
            readonly superTypes: ["SidePattern"];
        };
        readonly SymmetricPattern: {
            readonly name: "SymmetricPattern";
            readonly properties: {};
            readonly superTypes: [];
        };
        readonly SymmetricRelationship: {
            readonly name: "SymmetricRelationship";
            readonly properties: {
                readonly arrow: {
                    readonly name: "arrow";
                };
                readonly left: {
                    readonly name: "left";
                };
                readonly pattern: {
                    readonly name: "pattern";
                };
                readonly right: {
                    readonly name: "right";
                };
            };
            readonly superTypes: ["Relationship"];
        };
        readonly Team: {
            readonly name: "Team";
            readonly properties: {
                readonly name: {
                    readonly name: "name";
                };
            };
            readonly superTypes: ["Type"];
        };
        readonly ThisRef: {
            readonly name: "ThisRef";
            readonly properties: {
                readonly link: {
                    readonly name: "link";
                    readonly referenceType: "BoundedContext";
                };
            };
            readonly superTypes: ["BoundedContextRef"];
        };
        readonly Type: {
            readonly name: "Type";
            readonly properties: {};
            readonly superTypes: ["StructureElement"];
        };
    };
}
export declare const reflection: DomainLangAstReflection;