@atomic-ehr/fhirpath 0.0.1-canary.0c6931e.20250727185306

package/dist/index.d.ts

@@ -0,0 +1,462 @@
+declare enum TokenType {
+    LITERAL = "LITERAL",// Generic literal token for registry-based literals
+    NULL = "NULL",// {} (nullLiteral in grammar)
+    TRUE = "TRUE",// true
+    FALSE = "FALSE",// false
+    STRING = "STRING",// 'string value'
+    NUMBER = "NUMBER",// 123, 45.67, 0123 (allows leading zeros)
+    DATE = "DATE",// @2024, @2024-01, @2024-01-15
+    DATETIME = "DATETIME",// @2024-01-15T10:30:00Z
+    TIME = "TIME",// @T14:30:00
+    IDENTIFIER = "IDENTIFIER",// [A-Za-z_][A-Za-z0-9_]*
+    DELIMITED_IDENTIFIER = "DELIMITED_IDENTIFIER",// `identifier`
+    THIS = "THIS",// $this
+    INDEX = "INDEX",// $index
+    TOTAL = "TOTAL",// $total
+    ENV_VAR = "ENV_VAR",// %context, %`vs-name`
+    DOT = "DOT",// .
+    LBRACKET = "LBRACKET",// [
+    RBRACKET = "RBRACKET",// ]
+    LPAREN = "LPAREN",// (
+    RPAREN = "RPAREN",// )
+    PLUS = "PLUS",// +
+    MINUS = "MINUS",// -
+    STAR = "STAR",// *
+    SLASH = "SLASH",// /
+    DIV = "DIV",// div
+    MOD = "MOD",// mod
+    CONCAT = "CONCAT",// &
+    IS = "IS",// is
+    AS = "AS",// as
+    PIPE = "PIPE",// |
+    LT = "LT",// <
+    LTE = "LTE",// <=
+    GT = "GT",// >
+    GTE = "GTE",// >=
+    EQ = "EQ",// =
+    NEQ = "NEQ",// !=
+    EQUIV = "EQUIV",// ~
+    NEQUIV = "NEQUIV",// !~
+    IN = "IN",// in
+    CONTAINS = "CONTAINS",// contains
+    AND = "AND",// and
+    OR = "OR",// or
+    XOR = "XOR",// xor
+    IMPLIES = "IMPLIES",// implies
+    NOT = "NOT",// not
+    LBRACE = "LBRACE",// {
+    RBRACE = "RBRACE",// }
+    COMMA = "COMMA",// ,
+    EOF = "EOF",
+    UNIT = "UNIT",// year, month, 'mg', etc.
+    WS = "WS",// Whitespace
+    COMMENT = "COMMENT",// /* Multi-line comment */
+    LINE_COMMENT = "LINE_COMMENT"
+}
+interface Position$2 {
+    line: number;
+    column: number;
+    offset: number;
+}
+declare enum Channel {
+    DEFAULT = 0,
+    HIDDEN = 1
+}
+interface Token {
+    type: TokenType;
+    value: string;
+    position: Position$2;
+    channel?: Channel;
+    operation?: any;
+    literalValue?: any;
+}
+
+declare enum ErrorCode {
+    PARSE_ERROR = "PARSE_ERROR",
+    SYNTAX_ERROR = "SYNTAX_ERROR",
+    UNEXPECTED_TOKEN = "UNEXPECTED_TOKEN",
+    UNTERMINATED_STRING = "UNTERMINATED_STRING",
+    INVALID_ESCAPE = "INVALID_ESCAPE",
+    UNCLOSED_PARENTHESIS = "UNCLOSED_PARENTHESIS",
+    UNCLOSED_BRACKET = "UNCLOSED_BRACKET",
+    UNCLOSED_BRACE = "UNCLOSED_BRACE",
+    MISSING_ARGUMENTS = "MISSING_ARGUMENTS",
+    INVALID_OPERATOR = "INVALID_OPERATOR",
+    EXPECTED_EXPRESSION = "EXPECTED_EXPRESSION",
+    EXPECTED_IDENTIFIER = "EXPECTED_IDENTIFIER",
+    MULTIPLE_ERRORS = "MULTIPLE_ERRORS",
+    INVALID_CHARACTER = "INVALID_CHARACTER",
+    TYPE_ERROR = "TYPE_ERROR",
+    TYPE_MISMATCH = "TYPE_MISMATCH",
+    UNKNOWN_TYPE = "UNKNOWN_TYPE",
+    CARDINALITY_ERROR = "CARDINALITY_ERROR",
+    RUNTIME_ERROR = "RUNTIME_ERROR",
+    UNDEFINED_VARIABLE = "UNDEFINED_VARIABLE",
+    UNDEFINED_FUNCTION = "UNDEFINED_FUNCTION",
+    INVALID_ARGUMENT = "INVALID_ARGUMENT",
+    DIVISION_BY_ZERO = "DIVISION_BY_ZERO",
+    ANALYSIS_ERROR = "ANALYSIS_ERROR",
+    UNREACHABLE_CODE = "UNREACHABLE_CODE",
+    AMBIGUOUS_TYPE = "AMBIGUOUS_TYPE"
+}
+declare class FHIRPathError extends Error {
+    code: ErrorCode;
+    location?: Location | undefined;
+    expression?: string | undefined;
+    constructor(message: string, code: ErrorCode, location?: Location | undefined, expression?: string | undefined);
+    toString(): string;
+}
+
+interface ParserOptions {
+    maxErrors?: number;
+    throwOnError?: boolean;
+    trackRanges?: boolean;
+    errorRecovery?: boolean;
+}
+interface ParseResult {
+    ast: ASTNode;
+    diagnostics: ParseDiagnostic[];
+    hasErrors: boolean;
+    isPartial?: boolean;
+    ranges?: Map<ASTNode, TextRange>;
+}
+interface ParseDiagnostic {
+    range: TextRange;
+    severity: DiagnosticSeverity;
+    code: ErrorCode;
+    message: string;
+    source: 'fhirpath-parser';
+    relatedInformation?: RelatedInformation[];
+}
+declare enum DiagnosticSeverity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4
+}
+interface TextRange {
+    start: Position$1;
+    end: Position$1;
+}
+interface Position$1 {
+    line: number;
+    character: number;
+    offset: number;
+}
+interface RelatedInformation {
+    location: TextRange;
+    message: string;
+}
+
+interface ASTNode {
+    type: NodeType;
+    position: Position;
+    range?: TextRange;
+    resultType?: unknown;
+    isSingleton?: boolean;
+}
+interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
+declare enum NodeType {
+    Identifier = 0,
+    TypeOrIdentifier = 1,// Uppercase identifiers that could be types (Patient, Observation)
+    Binary = 2,// All binary operators including dot
+    Unary = 3,// unary +, -, not
+    Union = 4,// | operator (special handling for multiple operands)
+    Function = 5,// Function calls
+    Literal = 6,// numbers, strings, booleans, dates, null
+    Variable = 7,// $this, $index, $total, %var
+    Collection = 8,// {} empty collection or {expr1, expr2, ...}
+    MembershipTest = 9,// 'is' operator
+    TypeCast = 10,// 'as' operator
+    TypeReference = 11,// Type name in ofType()
+    Index = 12,// [] indexing
+    Error = "Error",// Error recovery node
+    Incomplete = "Incomplete"
+}
+interface IdentifierNode extends ASTNode {
+    type: NodeType.Identifier;
+    name: string;
+}
+interface LiteralNode extends ASTNode {
+    type: NodeType.Literal;
+    value: any;
+    valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+    raw?: string;
+    operation?: any;
+}
+interface BinaryNode extends ASTNode {
+    type: NodeType.Binary;
+    operator: TokenType;
+    operation?: any;
+    left: ASTNode;
+    right: ASTNode;
+}
+interface UnaryNode extends ASTNode {
+    type: NodeType.Unary;
+    operator: TokenType;
+    operation?: any;
+    operand: ASTNode;
+}
+interface FunctionNode extends ASTNode {
+    type: NodeType.Function;
+    name: ASTNode;
+    arguments: ASTNode[];
+    operation?: any;
+}
+interface VariableNode extends ASTNode {
+    type: NodeType.Variable;
+    name: string;
+}
+interface IndexNode extends ASTNode {
+    type: NodeType.Index;
+    expression: ASTNode;
+    index: ASTNode;
+}
+interface UnionNode extends ASTNode {
+    type: NodeType.Union;
+    operands: ASTNode[];
+}
+interface MembershipTestNode extends ASTNode {
+    type: NodeType.MembershipTest;
+    expression: ASTNode;
+    targetType: string;
+}
+interface TypeCastNode extends ASTNode {
+    type: NodeType.TypeCast;
+    expression: ASTNode;
+    targetType: string;
+}
+interface CollectionNode extends ASTNode {
+    type: NodeType.Collection;
+    elements: ASTNode[];
+}
+interface TypeReferenceNode extends ASTNode {
+    type: NodeType.TypeReference;
+    typeName: string;
+}
+
+/**
+ * Type system interfaces for FHIRPath type analysis
+ *
+ * Uses opaque type references to allow flexible implementation
+ */
+type TypeRef = unknown;
+
+/**
+ * Unified runtime context that works with both interpreter and compiler.
+ * Uses prototype-based inheritance for efficient context copying.
+ *
+ * Variable Storage Convention:
+ * - Special variables: $this, $index, $total (prefixed with $)
+ * - Environment variables: %context, %resource, %rootResource (stored with % prefix)
+ * - User-defined variables: stored with % prefix (e.g., %x, %y)
+ */
+interface RuntimeContext {
+    input: any[];
+    focus: any[];
+    variables: Record<string, any>;
+}
+
+interface FHIRPathExpression {
+    readonly ast: ASTNode;
+    evaluate(input?: any, context?: EvaluationContext): any[];
+    compile(options?: CompileOptions): CompiledExpression;
+    analyze(options?: AnalyzeOptions): AnalysisResult;
+    toString(): string;
+}
+interface CompiledExpression {
+    (input?: any, context?: EvaluationContext): any[];
+    readonly source: string;
+}
+interface EvaluationContext {
+    variables?: Record<string, any>;
+    environment?: Record<string, any>;
+    modelProvider?: ModelProvider;
+    customFunctions?: CustomFunctionMap;
+}
+type CustomFunction = (context: RuntimeContext, input: any[], ...args: any[]) => any[];
+type CustomFunctionMap = Record<string, CustomFunction>;
+interface ModelProvider {
+    resolveType(typeName: string): TypeRef | undefined;
+    getTypeHierarchy(typeName: string): string[];
+    getProperties(typeName: string): PropertyDefinition[];
+    getTypeName?(type: TypeRef): string;
+}
+interface PropertyDefinition {
+    name: string;
+    type: string;
+    isCollection: boolean;
+    isRequired: boolean;
+}
+interface CompileOptions {
+    optimize?: boolean;
+    sourceMap?: boolean;
+}
+interface AnalyzeOptions {
+    modelProvider?: ModelProvider;
+    strict?: boolean;
+}
+interface AnalysisResult {
+    type: TypeRef;
+    isSingleton: boolean;
+    errors: AnalysisError[];
+    warnings: AnalysisWarning[];
+}
+interface AnalysisError {
+    message: string;
+    location?: Location;
+    code: string;
+}
+interface AnalysisWarning {
+    message: string;
+    location?: Location;
+    code: string;
+}
+interface Location {
+    line: number;
+    column: number;
+    offset: number;
+    length: number;
+}
+interface RegistryAPI {
+    listFunctions(): OperationMetadata[];
+    listOperators(): OperationMetadata[];
+    listAllOperations(): OperationMetadata[];
+    hasOperation(name: string): boolean;
+    hasFunction(name: string): boolean;
+    hasOperator(symbol: string): boolean;
+    getOperationInfo(name: string): OperationInfo | undefined;
+    canRegisterFunction(name: string): boolean;
+}
+interface OperationMetadata {
+    name: string;
+    kind: 'function' | 'operator' | 'literal';
+    syntax: {
+        notation: string;
+    };
+}
+interface OperationInfo extends OperationMetadata {
+    signature: {
+        input?: {
+            types?: string[];
+            cardinality?: 'singleton' | 'collection' | 'any';
+        };
+        parameters?: Array<{
+            name: string;
+            types?: string[];
+            cardinality?: 'singleton' | 'collection' | 'any';
+            optional?: boolean;
+        }>;
+        output?: {
+            type?: string | 'dynamic';
+            cardinality?: 'singleton' | 'collection' | 'preserve-input';
+        };
+    };
+    description?: string;
+    examples?: string[];
+}
+interface FHIRPathBuilder {
+    withModelProvider(provider: ModelProvider): this;
+    withCustomFunction(name: string, fn: CustomFunction): this;
+    withVariable(name: string, value: any): this;
+    build(): FHIRPathAPI;
+}
+interface FHIRPathAPI {
+    parse(expression: string): FHIRPathExpression;
+    evaluate(expression: string | FHIRPathExpression, input?: any): any[];
+    compile(expression: string | FHIRPathExpression): CompiledExpression;
+    analyze(expression: string | FHIRPathExpression): AnalysisResult;
+    inspect(expression: string | FHIRPathExpression, input?: any, context?: EvaluationContext): InspectResult;
+    registry: RegistryAPI;
+}
+interface InspectResult {
+    result: any[];
+    expression: string;
+    ast: ASTNode;
+    executionTime: number;
+    traces: TraceEntry[];
+    evaluationSteps?: EvaluationStep[];
+    errors?: ErrorInfo[];
+    warnings?: WarningInfo[];
+}
+interface TraceEntry {
+    name: string;
+    values: any[];
+    timestamp: number;
+    location?: SourceLocation;
+    depth: number;
+}
+interface EvaluationStep {
+    nodeType: string;
+    expression: string;
+    input: any[];
+    output: any[];
+    variables: Record<string, any>;
+    timestamp: number;
+    duration: number;
+}
+interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+interface ErrorInfo {
+    message: string;
+    type: string;
+    location?: SourceLocation;
+    stack?: string;
+}
+interface WarningInfo {
+    message: string;
+    code: string;
+    location?: SourceLocation;
+}
+
+declare class PublicRegistryAPI implements RegistryAPI {
+    listFunctions(): OperationMetadata[];
+    listOperators(): OperationMetadata[];
+    listAllOperations(): OperationMetadata[];
+    hasOperation(name: string): boolean;
+    hasFunction(name: string): boolean;
+    hasOperator(symbol: string): boolean;
+    getOperationInfo(name: string): OperationInfo | undefined;
+    canRegisterFunction(name: string): boolean;
+    private toMetadata;
+    private toOperationInfo;
+    private extractTypes;
+}
+
+declare function parse(expression: string, options?: ParserOptions): ParseResult;
+declare function parseForEvaluation(expression: string): ASTNode;
+declare function isStandardResult(result: ParseResult): result is ParseResult;
+declare function isDiagnosticResult(result: ParseResult): result is ParseResult & {
+    isPartial: boolean;
+    ranges: Map<ASTNode, TextRange>;
+};
+declare function validate(expression: string): {
+    valid: boolean;
+    diagnostics: ParseDiagnostic[];
+};
+declare function evaluate(expression: string | FHIRPathExpression, input?: any, context?: EvaluationContext): any[];
+declare function compile(expression: string | FHIRPathExpression, options?: CompileOptions): CompiledExpression;
+declare function analyze(expression: string | FHIRPathExpression, options?: AnalyzeOptions): AnalysisResult;
+declare const registry: PublicRegistryAPI;
+
+declare class FHIRPath {
+    static builder(): FHIRPathBuilder;
+}
+
+declare const _default: {
+    parse: typeof parse;
+    parseForEvaluation: typeof parseForEvaluation;
+    evaluate: typeof evaluate;
+    compile: typeof compile;
+    analyze: typeof analyze;
+    registry: PublicRegistryAPI;
+};
+
+export { type ASTNode, type AnalysisError, type AnalysisResult, type AnalysisWarning, type AnalyzeOptions, type BinaryNode, type CollectionNode, type CompileOptions, type CompiledExpression, type CustomFunction, type CustomFunctionMap, DiagnosticSeverity, ErrorCode, type EvaluationContext, FHIRPath, type FHIRPathAPI, type FHIRPathBuilder, FHIRPathError, type FHIRPathExpression, type FunctionNode, type IdentifierNode, type IndexNode, type LiteralNode, type Location, type MembershipTestNode, type ModelProvider, NodeType, type OperationInfo, type OperationMetadata, type ParseDiagnostic, type ParseResult, type ParserOptions, type Position, type PropertyDefinition, type RegistryAPI, type Position$1 as TextPosition, type TextRange, type Token, TokenType, type TypeCastNode, type TypeReferenceNode, type UnaryNode, type UnionNode, type VariableNode, analyze, compile, _default as default, evaluate, isDiagnosticResult, isStandardResult, parse, parseForEvaluation, registry, validate };