@atomic-ehr/fhirpath 0.0.1-canary.1825db0.20250725140030

package/dist/index.d.ts

@@ -0,0 +1,398 @@
+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$1 {
+    line: number;
+    column: number;
+    offset: number;
+}
+declare enum Channel {
+    DEFAULT = 0,
+    HIDDEN = 1
+}
+interface Token {
+    type: TokenType;
+    value: string;
+    position: Position$1;
+    channel?: Channel;
+    operation?: any;
+    literalValue?: any;
+}
+
+interface ASTNode {
+    type: NodeType;
+    position: Position;
+    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
+}
+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): FHIRPathExpression;
+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 enum ErrorCode {
+    PARSE_ERROR = "PARSE_ERROR",
+    SYNTAX_ERROR = "SYNTAX_ERROR",
+    UNEXPECTED_TOKEN = "UNEXPECTED_TOKEN",
+    UNTERMINATED_STRING = "UNTERMINATED_STRING",
+    INVALID_ESCAPE = "INVALID_ESCAPE",
+    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;
+}
+
+declare const _default: {
+    parse: typeof parse;
+    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, 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 Position, type PropertyDefinition, type RegistryAPI, type Token, TokenType, type TypeCastNode, type TypeReferenceNode, type UnaryNode, type UnionNode, type VariableNode, analyze, compile, _default as default, evaluate, parse, registry };