import { TooltipPosition } from '@angular/material/tooltip';
import { KeyValue, KeyValueObject } from '../../../common/KeyValue';
import { PreApplyMessages, PreApplyValidator } from '../../interfaces/pre-apply-validator.interface';
import { FormControl, ValidatorFn } from '@angular/forms';
import { Observable } from 'rxjs';
export declare enum ChartType {
    LINE = "LINE",
    BAR = "BAR",
    PIE = "PIE",
    GROUPING = "GROUPING",
    PREDICTION = "PREDICTION",
    DOUGHNUT = "DOUGHNUT"
}
export type TogglesContainer = {
    id: string;
    toggles: Array<ToggleButtonGroup>;
};
export type ToggleButtonGroup = {
    title?: string;
    toggleOptions: Array<KeyValue>;
} & Mappable;
export type SelectableOption = {
    label: string;
    selected: boolean;
    tooltip?: string;
    tooltipPosition?: TooltipPosition;
} & Mappable;
export declare enum LogicalOperator {
    AND = "AND",
    OR = "OR"
}
export type Multiselection<T extends string | number | boolean> = {
    items: Array<T>;
    isIncludeMode: boolean;
};
export type Labels = {
    selectedLabels: Array<Label>;
    logicOperation: LogicalOperator;
};
export type Tags = {
    selectedTags: Array<Tag>;
    logicOperation: LogicalOperator;
};
export type Item = {
    display: string;
    value: string | number | boolean;
    cloudProvider?: string;
    cloudProviderName?: string;
    img?: string;
};
export type ToggleSelectedOption = {
    type: string;
    mode: string;
};
export type Slider = {
    min: number;
    max: number;
    step: number;
} & Mappable;
export type SliderWrapper = {
    control: FormControl<number>;
} & Slider;
export type SingleSelectValidation<T> = {
    validation?: (selection: T) => boolean;
    tooltip?: string;
};
export type SingleSelectChartOptions<T> = {
    title?: string;
    items: Array<KeyValue & SingleSelectValidation<T>>;
} & Mappable;
export type SelectedSingleChartOption = {
    id: string;
    item: KeyValue;
};
export type Label = {
    label: string;
    labelValues: Array<string> | null;
};
export type LabelWithOneValue = {
    label: string;
    value: string;
};
export type Tag = {
    tag: string;
    tagValues: Array<string>;
    namespace: string;
};
export declare class InvoiceMonth {
    parsedDate: string;
    bigQueryInvoiceMonth: string;
    constructor(month: string);
}
/**
 * Base class representing period selection.
 */
export declare class Period {
    /**
     * Type of selected period
     * @example PREDEFINED | DATE_RANGE | INVOICE_MONTH
     */
    type: PeriodType;
    /**
     * Used for DATE_RANGE
     */
    fromDate: moment.Moment;
    /**
     * Used for DATE_RANGE
     */
    toDate: moment.Moment;
    /**
     * Used for PREDEFINED
     */
    predefinedType: string;
    /**
     * INVOICE_MONTH selection
     */
    selectedInvoiceMonths?: string[];
}
export declare enum PeriodType {
    PREDEFINED = "PREDEFINED",
    DATE_RANGE = "DATE_RANGE",
    INVOICE_MONTH = "INVOICE_MONTH"
}
/**
 * Contains the metadata needed to create a Multiselect tab.
 * Extends FilterTab.
 */
export type MultiSelectTab = ({
    type: 'MULTI_SELECT';
    items: Array<Item>;
    hideExclude?: boolean;
    keepTitleOverCloudProvider?: boolean;
    lazyLoadItems?: never;
    loadItemsByIds?: never;
} & Searchable & Mappable) | ({
    type: 'MULTI_SELECT';
    items: Array<Item>;
    hideExclude?: boolean;
    keepTitleOverCloudProvider?: boolean;
    lazyLoadItems: (searchString: string, length?: number) => Observable<Array<Item>>;
    loadItemsByIds?: (ids: (string | number | boolean)[]) => Observable<Array<Item>>;
} & Searchable & Mappable);
/**
 * Contains the metadata needed to create a Single select tab.
 * Extends FilterTab.
 */
export type SingleSelectTab = {
    type: 'SINGLE_SELECT';
    /**
     * The selectable data
     */
    items: Array<Item>;
} & Mappable;
/**
 * Wrapper containing the validation functions and error messages map.
 */
export type InputFieldValidators = {
    validatorFunctions: Array<ValidatorFn>;
    /**
     * A map where the key should be the key of ValidationErrors
     * returned by the validation function and the value should be the message.
     */
    errorMessages: Map<string, string>;
};
export type InputField = {
    label: string;
    validators?: InputFieldValidators;
    overrideChipText?: string;
} & Mappable & (TextInputField | NumberInputField | CheckboxInputField);
export type TextInputField = {
    type: 'text';
    searchInputField?: (key: string) => Observable<Array<string>>;
};
export type NumberInputField = {
    type: 'number';
};
export type CheckboxInputField = {
    type: 'checkbox';
};
export type InputTab = {
    type: 'INPUT';
    inputs: Array<InputField>;
    cloudProvider?: string;
};
/**
 * Contains the metadata to create a Label tab.
 * Extends FilterTab.
 */
export type LabelTab = {
    type: 'LABEL';
    additionalActionId?: string;
    addButtonName: string;
    additionalActionName?: string;
    /**
     * Called when the key value of a label has changed.
     *
     * @param key - The searched key
     * @returns Possible keys for the given search key
     */
    searchKeys: (key: string) => Observable<Array<string>>;
    /**
     * Called when a label value's value has changed.
     *
     * @param key - The searched key
     * @param value - The searched value
     * @returns Posible values for the given search value.
     */
    searchValues: (key: string, value: string) => Observable<Array<string>>;
    /**
     * Called when a global search is initiated from the 'All' tab
     *
     * @param search The searched word
     * @returns Labels that contain the search word.
     */
    globalSearch: (search: string) => Observable<Array<Label>>;
} & Searchable & Mappable;
export type TagTab = {
    type: 'TAG';
    cloudProvider: string;
    searchNamespace: (namespace: string) => Observable<Array<string>>;
    searchKeys: (key: string, namespace: string) => Observable<Array<string>>;
    searchValues: (key: string, value: string, namespace: string) => Observable<Array<string>>;
    globalSearch: (search: string) => Observable<Array<Tag>>;
} & Mappable & Searchable;
export interface Mappable {
    /**
     * The name of the property in the output object to which the selection will be mapped.
     */
    id: string;
}
export interface Searchable {
    /**
     * The prefix will be used in the global search to narrow the search to items from a specific tab.
     */
    searchPrefix: string;
}
export declare function isSearchable(s: any): s is Searchable;
export declare function isMappable(m: any): m is Mappable;
/**
 * Description of a tab.
 */
export type FilterTab = {
    /**
     * The title of the tab.
     */
    title: string;
} & (MultiSelectTab | SingleSelectTab | LabelTab | TagTab | InputTab);
export type NonEmptyArray<T> = [T, ...T[]] | [...T[], T] | [T, ...T[], T];
/**
 * Base class for all modifiers.
 */
export declare abstract class ModifierOptions<T> implements PreApplyValidator<T> {
    preApplyValidation?: (selection: T) => PreApplyMessages;
}
/**
 * Grouping will be visualised only if GroupingOptionsm
 * are passed in the GcpFilterOptions.
 */
export declare class GroupingOptions<T> extends ModifierOptions<T> implements Mappable {
    id: string;
    /**
     * The selectable options that will be used in the dropdown field.
     * The elements can be either {@link KeyValue} or an Array of {@link KeyValue}.
     * If the element is an Array of {@link KeyValue} hierarchy rules will be applied on
     * the selection order.
     *
     * @Example [{
     *    display: 'Period - Day',
     *    value: 'PERIOD_DAY',
     * }]
     */
    items: Array<KeyValueObject | Array<KeyValueObject>>;
}
export declare class PeriodOptions<T> extends ModifierOptions<T> implements Mappable {
    id: string;
    predefinedPeriods?: Array<KeyValue>;
    invoiceMonths?: Array<InvoiceMonth>;
    hideCustomPeriod?: boolean;
}
export declare class ChartOptions<T> extends ModifierOptions<T> {
    selectableOptions?: Array<SelectableOption>;
    togglesContainer?: TogglesContainer;
    sliders?: Array<Slider>;
    chartType?: FormControl<ChartType>;
    singleSelectOptions?: SingleSelectChartOptions<T>;
}
export declare class FilterOptions<T> extends ModifierOptions<T> {
    tabs: NonEmptyArray<FilterTab>;
}