import { ENGINES, AST_TYPES, RESPONSE_LEVEL, AST_PRIMITIVES, CUSTOM_PRIMITIVE, Primitive, OPERATION_SCOPE } from '.';
import { BaseError } from '../errors';
interface FunctionElementDefinition {
    identifier: string;
}
export interface FunctionDefinition extends FunctionElementDefinition {
    recursiveStartIn?: number;
    operationScope: OPERATION_SCOPE;
    functionScope: Array<OPERATION_SCOPE>;
    transpiler: EnginesFunction;
    parameters?: Array<FunctionParameter>;
    primitiveResult: Primitive | ((args: CommonAST[]) => Primitive);
}
export type EnginesFunction = {
    [key in ENGINES]: Function;
};
export interface FunctionParameter extends FunctionElementDefinition {
    optional: boolean;
    generic?: boolean;
    expectedPrimitive?: AST_PRIMITIVES;
    validator: Array<ValidatorFunctionParameter>;
}
export interface ProcessNodeResult {
    value: any;
    type: AST_TYPES;
    dataType: Primitive;
    node: CommonAST;
}
export interface ValidatorParameterContext {
    fnNode: FunctionCallAST;
    argument: ProcessNodeResult;
    globalContext?: FormulaContext;
}
export interface ValidatorFunctionParameter {
    (value: any, dataType: Primitive | undefined, context: ValidatorParameterContext): ValidatorResponse;
}
export interface ValidatorResponse {
    valid: boolean;
    code?: string;
    source?: RESPONSE_LEVEL;
    message?: string;
    info?: any;
    mismatchData?: ValidatorExpectedInfo;
}
export interface ValidatorParameterResponse extends ValidatorResponse {
    parameter: FunctionParameter;
    argumentIndex: number;
}
export interface ValidatorExpectedInfo {
    primitive: Primitive;
    customPrimitive?: CUSTOM_PRIMITIVE;
    customReceived?: CUSTOM_PRIMITIVE;
    type?: AST_TYPES;
}
export interface TranspilationResponse {
    valid: boolean;
    expression?: string;
    errors?: BaseError[];
    details?: TranspilationDetails;
}
export interface AggregatedDefinition {
    key: string;
    columnId: string;
    property?: string;
    aggregate: string;
}
export type AggregateMap = Map<string, AggregatedDefinition>;
interface TranspilationDetails {
    script: string | undefined;
    customFunctions: string | undefined;
    paramsDefinitions?: Array<AggregatedDefinition>;
}
export interface FunctionList {
    [identifier: string]: FunctionDefinition;
}
export interface ProgramPosition {
    from: number;
    to: number;
}
export interface CommonAST extends ProgramPosition {
    type: AST_TYPES;
    primitive: Primitive;
    isValidAggregate?: boolean;
}
export interface ProgramAST extends CommonAST {
    exp: string;
    lang: string;
    version: string;
    body?: CommonAST;
    errors?: BaseError[];
    variables?: VariableContextDefinition[];
    formulaFunctions?: CommonAST[];
    flatBody?: CommonAST[];
}
export interface UnaryExpressionAST extends CommonAST {
    operator: string;
    operatorNode?: ProgramPosition;
    validOperators: string[];
    right: CommonAST;
}
export interface BinaryExpressionAST extends UnaryExpressionAST {
    left: CommonAST;
}
export interface FunctionCallAST extends CommonAST {
    name: string;
    arguments: Array<CommonAST>;
    functionScope: OPERATION_SCOPE;
    parenthesisStart: boolean;
    parenthesisEnd: boolean;
    functionText: string;
    functionIdentifier: ProgramPosition;
}
export type ValueASTType = string | boolean | number | CommonAST[] | null | Date;
export interface CommonValueAST extends CommonAST {
    value: ValueASTType;
}
export interface UnknownAST extends CommonAST {
    text: string;
}
export interface VariableAST extends CommonValueAST {
    context?: VariableContextDefinition;
}
export interface ExternalFormulaAST extends VariableAST {
    isExternalFormula: boolean;
}
export interface LiteralAST extends CommonValueAST {
    dataType: AST_PRIMITIVES;
}
export interface VariableContextDefinition {
    label: string;
    id: string;
    replacement?: string;
    type: AST_PRIMITIVES;
    extras?: Record<string, any>;
    isExternalFormula?: boolean;
}
export interface FormulaContext {
    model?: VariableContextDefinition[];
    currentFormulaId?: string;
    currentInputScope?: OPERATION_SCOPE;
    timezone?: TimezoneDefinition;
    useSampleData?: boolean;
    sampleData?: any;
}
export interface FormulaInference {
    errorList: BaseError[];
    formulaVariables: VariableContextDefinition[];
    formulaFunctions: CommonAST[];
    flatBody: CommonAST[];
}
interface TimezoneDefinition {
    offset: string;
}
export type VariableASTType = AST_TYPES.variable | AST_TYPES.column | AST_TYPES.token | AST_TYPES.externalFormula;
export interface IsValidOrError {
    isValid: boolean;
    error?: BaseError;
}
export type DateUnit = 'Y' | 'M' | 'D';
export type DateTimeUnit = DateUnit | 'H' | 'MI' | 'S';
export type DateDifUnitParam = DateTimeUnit;
export type DayOfWeekFormat = 'Day' | 'D';
export {};