import type { DefinitionBlueprint, DialectFunctionOverloadDef, ImplementationBlueprint } from './util';
type D = DefinitionBlueprint;
type I = ImplementationBlueprint;
type DefinitionsFor<T> = {
    [key in keyof T]: D;
};
type ImplementationsFor<T> = {
    [key in keyof T]?: I;
};
type DefinitionFor<T> = T extends D ? D : DefinitionsFor<T>;
type ImplementationFor<T> = T extends D ? I : ImplementationsFor<T>;
type DefinitionMap<T> = {
    [key in keyof T]: DefinitionFor<T[key]>;
};
type ImplementationMap<T> = {
    [key in keyof T]?: ImplementationFor<T[key]>;
};
type Standard = {
    abs: D;
    acos: D;
    ascii: D;
    asin: D;
    atan2: D;
    atan: D;
    byte_length: D;
    ceil: D;
    chr: D;
    coalesce: D;
    concat: {
        empty: D;
        variadic: D;
    };
    cos: D;
    div: D;
    ends_with: D;
    exp: D;
    floor: D;
    greatest: D;
    ifnull: D;
    is_inf: D;
    is_nan: D;
    least: D;
    length: D;
    ln: D;
    log: D;
    lower: D;
    ltrim: {
        whitespace: D;
        characters: D;
    };
    nullif: D;
    pi: D;
    pow: D;
    rand: D;
    regexp_extract: D;
    string_repeat: D;
    replace: {
        string: D;
        regular_expression: D;
    };
    round: {
        to_integer: D;
        to_precision: D;
    };
    rtrim: {
        whitespace: D;
        characters: D;
    };
    sign: D;
    sin: D;
    sqrt: D;
    starts_with: D;
    strpos: D;
    substr: {
        position_only: D;
        with_length: D;
    };
    tan: D;
    trim: {
        whitespace: D;
        characters: D;
    };
    trunc: {
        to_integer: D;
        to_precision: D;
    };
    unicode: D;
    upper: D;
    stddev: D;
    avg_moving: {
        preceding: D;
        following: D;
    };
    first_value: D;
    lag: {
        bare: D;
        with_offset: D;
        with_default: D;
    };
    last_value: D;
    lead: {
        bare: D;
        with_offset: D;
        with_default: D;
    };
    max_cumulative: D;
    max_window: D;
    min_cumulative: D;
    min_window: D;
    rank: D;
    dense_rank: D;
    row_number: D;
    sum_cumulative: D;
    sum_moving: {
        preceding: D;
        following: D;
    };
    sum_window: D;
    sql_boolean: D;
    sql_date: D;
    sql_number: D;
    sql_string: D;
    sql_timestamp: D;
};
export type MalloyStandardFunctionDefinitions = DefinitionMap<Standard>;
export type MalloyStandardFunctionImplementations = ImplementationMap<Standard>;
export declare const MALLOY_STANDARD_FUNCTIONS: MalloyStandardFunctionDefinitions;
export declare function getMalloyStandardFunctions(): {
    [name: string]: DialectFunctionOverloadDef[];
};
export declare function expandOverrideMap(overrides: MalloyStandardFunctionImplementations): {
    [name: string]: DialectFunctionOverloadDef[];
};
export {};