import { type Explore } from '../types/explore';
import { DimensionType, MetricType, TableCalculationType, type CompiledDimension, type CustomDimension, type CustomSqlDimension, type Dimension, type Field, type Item, type ItemsMap, type TableCalculation } from '../types/field';
import { type AdditionalMetric } from '../types/metricQuery';
export declare const isNumericType: (type: DimensionType | MetricType | TableCalculationType) => boolean;
export declare const getItemId: (item: ItemsMap[string] | AdditionalMetric | Pick<Field, "name" | "table">) => string;
export declare const getItemLabelWithoutTableName: (item: Item) => string;
export declare const getItemLabel: (item: Item) => string;
export declare function getItemType(item: ItemsMap[string] | AdditionalMetric): DimensionType | MetricType | TableCalculationType;
export declare function isNumericItem(item: Field | AdditionalMetric | TableCalculation | CustomDimension | undefined): boolean;
export declare const isStringDimension: (item: Field | AdditionalMetric | TableCalculation | CustomDimension | undefined) => boolean;
export declare const getItemIcon: (item: Field | TableCalculation | AdditionalMetric | CustomDimension) => "tag" | "numerical" | "function";
export declare const isDateItem: (item: Field | AdditionalMetric | TableCalculation | CustomSqlDimension | undefined) => boolean;
/**
 * Gets the effective type for formatting purposes.
 * For metrics that return date/timestamp values (MIN/MAX on date dimensions),
 * returns the underlying dimension type instead of the metric type.
 *
 * @param item - The item to get the effective type for
 * @param itemsMap - Optional itemsMap to look up dimension types
 * @returns The effective type for formatting (DimensionType, MetricType, or TableCalculationType)
 */
export declare const getEffectiveItemType: (item: ItemsMap[string] | AdditionalMetric | undefined, itemsMap?: ItemsMap) => DimensionType | MetricType | TableCalculationType | undefined;
/**
 * Checks if a metric returns a date/timestamp value.
 * This is true when:
 * 1. The metric type is directly DATE or TIMESTAMP
 * 2. The metric type is MIN or MAX and the underlying dimension (via dimensionReference) is a date/timestamp
 *
 * @param item - The metric to check
 * @param itemsMap - Optional itemsMap to look up the dimension type from dimensionReference
 * @returns true if the metric returns a date/timestamp value
 */
export declare const isMetricWithDateValue: (item: ItemsMap[string] | AdditionalMetric | undefined, itemsMap?: ItemsMap) => boolean;
export declare const replaceDimensionInExplore: (explore: Explore, dimension: CompiledDimension) => {
    tables: {
        [x: string]: import("../types/explore").CompiledTable | {
            dimensions: {
                [x: string]: CompiledDimension;
            };
            name: string;
            label: string;
            originalName?: string;
            description?: string;
            database: string;
            schema: string;
            sqlTable: string;
            primaryKey?: string[];
            orderFieldsBy?: import("..").OrderFieldsByStrategy;
            groupLabel?: string;
            sqlWhere?: string;
            requiredFilters?: import("..").ModelRequiredFilterRule[];
            hidden?: boolean;
            requiredAttributes?: Record<string, string | string[]>;
            anyAttributes?: Record<string, string | string[]>;
            groupDetails?: Record<string, import("..").GroupType>;
            defaultTimeDimension?: import("..").DefaultTimeDimension;
            defaultShowUnderlyingValues?: string[];
            aiHint?: string | string[];
            warnings?: import("../types/explore").InlineError[];
            dbtPackageName?: string;
            ymlPath?: string;
            sqlPath?: string;
            metrics: Record<string, import("../types/field").CompiledMetric>;
            lineageGraph: import("..").LineageGraph;
            source?: import("../types/field").Source | undefined;
            uncompiledSqlWhere?: string;
            parameterReferences?: string[];
            parameters?: import("..").LightdashProjectConfig["parameters"];
            sets?: Record<string, import("..").FieldSetDefinition>;
        };
    };
    name: string;
    label: string;
    tags: string[];
    groupLabel?: string;
    groups?: string[];
    baseTable: string;
    joinedTables: import("../types/explore").CompiledExploreJoin[];
    unfilteredTables?: {
        [tableName: string]: import("../types/explore").CompiledTable;
    };
    targetDatabase: import("..").SupportedDbtAdapter;
    warehouse?: string;
    databricksCompute?: string;
    ymlPath?: string;
    sqlPath?: string;
    type?: import("../types/explore").ExploreType;
    caseSensitive?: boolean;
    spotlight?: {
        visibility: import("..").LightdashProjectConfig["spotlight"]["default_visibility"];
        categories?: string[];
        owner?: string;
    };
    aiHint?: string | string[];
    parameters?: import("..").LightdashProjectConfig["parameters"];
    granularityLabels?: Partial<Record<import("..").TimeFrames, string>>;
    savedParameterValues?: import("..").ParametersValuesMap;
    preAggregates?: import("..").PreAggregateDef[];
    preAggregateSource?: import("../types/explore").PreAggregateSource;
    warnings?: import("../types/explore").InlineError[];
};
export declare const canApplyFormattingToCustomMetric: (item: Dimension, customMetricType: MetricType) => boolean;
/**
 * When selecting a field for the x axis,
 * we want to prioritize dimensions and date items
 * over metrics and table calculations
 * Used in CustomVisTemplate.tsx
 */
export declare const sortedItemsForXAxis: (itemsMap: ItemsMap | undefined) => ItemsMap[string][];
/**
 * When selecting a field for the y axis (and color/size values),
 * we want to prioritize numeric metrics and table calculations
 * over dimensions
 */
export declare const sortedItemsForYAxis: (itemsMap: ItemsMap | undefined) => ItemsMap[string][];
//# sourceMappingURL=item.d.ts.map