import type { SortingState, ColumnSort } from "@tanstack/react-table";
import { z } from "zod";
import type { TextFilterOperator, FilterType } from "@calcom/types/data-table";
export type { ColumnFilterMeta, FilterableColumn } from "@calcom/types/data-table";
declare const ColumnFilterType: {
    readonly SINGLE_SELECT: "ss";
    readonly MULTI_SELECT: "ms";
    readonly TEXT: "t";
    readonly NUMBER: "n";
    readonly DATE_RANGE: "dr";
};
type ColumnFilterTypeValues = typeof ColumnFilterType;
export type { SortingState } from "@tanstack/react-table";
export declare const SYSTEM_SEGMENT_PREFIX = "system_";
export { ColumnFilterType, TextFilterOperator };
export declare const textFilterOperators: readonly ["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"];
export declare const ZTextFilterOperator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
export type SingleSelectFilterValue = {
    type: ColumnFilterTypeValues["SINGLE_SELECT"];
    data: string | number;
};
export declare const ZSingleSelectFilterValue: z.ZodObject<{
    type: z.ZodLiteral<"ss">;
    data: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
}, "strip", z.ZodTypeAny, {
    data: string | number;
    type: "ss";
}, {
    data: string | number;
    type: "ss";
}>;
export type MultiSelectFilterValue = {
    type: ColumnFilterTypeValues["MULTI_SELECT"];
    data: Array<string | number>;
};
export declare const ZMultiSelectFilterValue: z.ZodObject<{
    type: z.ZodLiteral<"ms">;
    data: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
}, "strip", z.ZodTypeAny, {
    data: (string | number)[];
    type: "ms";
}, {
    data: (string | number)[];
    type: "ms";
}>;
export type TextFilterValue = {
    type: ColumnFilterTypeValues["TEXT"];
    data: {
        operator: TextFilterOperator;
        operand: string;
    };
};
export declare const ZTextFilterValue: z.ZodObject<{
    type: z.ZodLiteral<"t">;
    data: z.ZodObject<{
        operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
        operand: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    }, {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    };
    type: "t";
}, {
    data: {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    };
    type: "t";
}>;
declare const numberFilterOperators: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
export type NumberFilterOperator = (typeof numberFilterOperators)[number];
export declare const ZNumberFilterOperator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
export type NumberFilterValue = {
    type: ColumnFilterTypeValues["NUMBER"];
    data: {
        operator: NumberFilterOperator;
        operand: number;
    };
};
export declare const ZNumberFilterValue: z.ZodObject<{
    type: z.ZodLiteral<"n">;
    data: z.ZodObject<{
        operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
        operand: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    }, {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    };
    type: "n";
}, {
    data: {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    };
    type: "n";
}>;
export type DateRangeFilterValue = {
    type: ColumnFilterTypeValues["DATE_RANGE"];
    data: {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    };
};
export declare const ZDateRangeFilterValue: z.ZodObject<{
    type: z.ZodLiteral<"dr">;
    data: z.ZodObject<{
        startDate: z.ZodNullable<z.ZodString>;
        endDate: z.ZodNullable<z.ZodString>;
        preset: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    }, {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    };
    type: "dr";
}, {
    data: {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    };
    type: "dr";
}>;
export declare const ZFilterValue: z.ZodUnion<[z.ZodObject<{
    type: z.ZodLiteral<"ss">;
    data: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
}, "strip", z.ZodTypeAny, {
    data: string | number;
    type: "ss";
}, {
    data: string | number;
    type: "ss";
}>, z.ZodObject<{
    type: z.ZodLiteral<"ms">;
    data: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
}, "strip", z.ZodTypeAny, {
    data: (string | number)[];
    type: "ms";
}, {
    data: (string | number)[];
    type: "ms";
}>, z.ZodObject<{
    type: z.ZodLiteral<"t">;
    data: z.ZodObject<{
        operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
        operand: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    }, {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    };
    type: "t";
}, {
    data: {
        operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
        operand: string;
    };
    type: "t";
}>, z.ZodObject<{
    type: z.ZodLiteral<"n">;
    data: z.ZodObject<{
        operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
        operand: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    }, {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    };
    type: "n";
}, {
    data: {
        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
        operand: number;
    };
    type: "n";
}>, z.ZodObject<{
    type: z.ZodLiteral<"dr">;
    data: z.ZodObject<{
        startDate: z.ZodNullable<z.ZodString>;
        endDate: z.ZodNullable<z.ZodString>;
        preset: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    }, {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    };
    type: "dr";
}, {
    data: {
        startDate: string | null;
        endDate: string | null;
        preset: string;
    };
    type: "dr";
}>]>;
export type DateRangeFilterOptions = {
    range?: "past" | "custom";
    convertToTimeZone?: boolean;
};
export type TextFilterOptions = {
    allowedOperators?: TextFilterOperator[];
    placeholder?: string;
};
export type ColumnFilter = {
    id: string;
    value: FilterValue;
};
export declare const ZColumnFilter: z.ZodObject<{
    id: z.ZodString;
    value: z.ZodUnion<[z.ZodObject<{
        type: z.ZodLiteral<"ss">;
        data: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
    }, "strip", z.ZodTypeAny, {
        data: string | number;
        type: "ss";
    }, {
        data: string | number;
        type: "ss";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"ms">;
        data: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
    }, "strip", z.ZodTypeAny, {
        data: (string | number)[];
        type: "ms";
    }, {
        data: (string | number)[];
        type: "ms";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"t">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
            operand: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"n">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
            operand: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"dr">;
        data: z.ZodObject<{
            startDate: z.ZodNullable<z.ZodString>;
            endDate: z.ZodNullable<z.ZodString>;
            preset: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }>]>;
}, "strip", z.ZodTypeAny, {
    id: string;
    value: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    };
}, {
    id: string;
    value: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    };
}>;
export type FilterValueSchema<T extends FilterType> = T extends ColumnFilterTypeValues["SINGLE_SELECT"] ? typeof ZSingleSelectFilterValue : T extends ColumnFilterTypeValues["MULTI_SELECT"] ? typeof ZMultiSelectFilterValue : T extends ColumnFilterTypeValues["TEXT"] ? typeof ZTextFilterValue : T extends ColumnFilterTypeValues["NUMBER"] ? typeof ZNumberFilterValue : T extends ColumnFilterTypeValues["DATE_RANGE"] ? typeof ZDateRangeFilterValue : never;
export type FilterValue<T extends FilterType = FilterType> = T extends ColumnFilterTypeValues["SINGLE_SELECT"] ? SingleSelectFilterValue : T extends ColumnFilterTypeValues["MULTI_SELECT"] ? MultiSelectFilterValue : T extends ColumnFilterTypeValues["TEXT"] ? TextFilterValue : T extends ColumnFilterTypeValues["NUMBER"] ? NumberFilterValue : T extends ColumnFilterTypeValues["DATE_RANGE"] ? DateRangeFilterValue : never;
export type TypedColumnFilter<T extends FilterType> = {
    id: string;
    value: FilterValue<T>;
};
export type Sorting = ColumnSort;
export declare const ZSorting: z.ZodObject<{
    id: z.ZodString;
    desc: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    id: string;
    desc: boolean;
}, {
    id: string;
    desc: boolean;
}>;
export declare const ZSortingState: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    desc: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    id: string;
    desc: boolean;
}, {
    id: string;
    desc: boolean;
}>, "many">;
export declare const ZColumnSizing: z.ZodRecord<z.ZodString, z.ZodNumber>;
export declare const ZColumnVisibility: z.ZodRecord<z.ZodString, z.ZodBoolean>;
export type FacetedValue = {
    label: string;
    value: string | number;
    section?: string;
};
export type ActiveFilter = {
    f: string;
    v?: FilterValue;
};
export type ActiveFilters = ActiveFilter[];
export declare const ZActiveFilter: z.ZodObject<{
    f: z.ZodString;
    v: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
        type: z.ZodLiteral<"ss">;
        data: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
    }, "strip", z.ZodTypeAny, {
        data: string | number;
        type: "ss";
    }, {
        data: string | number;
        type: "ss";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"ms">;
        data: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
    }, "strip", z.ZodTypeAny, {
        data: (string | number)[];
        type: "ms";
    }, {
        data: (string | number)[];
        type: "ms";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"t">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
            operand: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"n">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
            operand: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"dr">;
        data: z.ZodObject<{
            startDate: z.ZodNullable<z.ZodString>;
            endDate: z.ZodNullable<z.ZodString>;
            preset: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }>]>>;
}, "strip", z.ZodTypeAny, {
    f: string;
    v?: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    } | undefined;
}, {
    f: string;
    v?: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    } | undefined;
}>;
export declare const ZActiveFilters: z.ZodArray<z.ZodObject<{
    f: z.ZodString;
    v: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
        type: z.ZodLiteral<"ss">;
        data: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
    }, "strip", z.ZodTypeAny, {
        data: string | number;
        type: "ss";
    }, {
        data: string | number;
        type: "ss";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"ms">;
        data: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
    }, "strip", z.ZodTypeAny, {
        data: (string | number)[];
        type: "ms";
    }, {
        data: (string | number)[];
        type: "ms";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"t">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
            operand: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }, {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }, {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"n">;
        data: z.ZodObject<{
            operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
            operand: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }, {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }, {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"dr">;
        data: z.ZodObject<{
            startDate: z.ZodNullable<z.ZodString>;
            endDate: z.ZodNullable<z.ZodString>;
            preset: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }, {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }, {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    }>]>>;
}, "strip", z.ZodTypeAny, {
    f: string;
    v?: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    } | undefined;
}, {
    f: string;
    v?: {
        data: {
            operator: "endsWith" | "startsWith" | "contains" | "equals" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
            operand: string;
        };
        type: "t";
    } | {
        data: string | number;
        type: "ss";
    } | {
        data: (string | number)[];
        type: "ms";
    } | {
        data: {
            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
            operand: number;
        };
        type: "n";
    } | {
        data: {
            startDate: string | null;
            endDate: string | null;
            preset: string;
        };
        type: "dr";
    } | undefined;
}>, "many">;
export type FilterSegmentOutput = {
    id: number;
    name: string;
    tableIdentifier: string;
    scope: "USER" | "TEAM";
    activeFilters: ActiveFilters;
    sorting: SortingState;
    columnVisibility: Record<string, boolean>;
    columnSizing: Record<string, number>;
    perPage: number;
    searchTerm: string | null;
    createdAt: Date;
    updatedAt: Date;
    userId: number;
    teamId: number | null;
    team: {
        id: number;
        name: string;
    } | null;
};
export type SystemFilterSegment = {
    id: string;
    name: string;
    activeFilters: ActiveFilters;
    sorting?: SortingState;
    columnVisibility?: Record<string, boolean>;
    columnSizing?: Record<string, number>;
    perPage?: number;
    searchTerm?: string | null;
    type: "system";
};
export type SystemFilterSegmentInternal = Omit<SystemFilterSegment, "perPage"> & {
    tableIdentifier: string;
    perPage: number;
};
export type UserFilterSegment = FilterSegmentOutput & {
    type: "user";
};
export type CombinedFilterSegment = SystemFilterSegmentInternal | UserFilterSegment;
export type SegmentIdentifier = {
    id: string;
    type: "system";
} | {
    id: number;
    type: "user";
};
export type SegmentStorage = {
    [tableIdentifier: string]: {
        segmentId: number;
    };
};
export declare const ZSegmentStorage: z.ZodRecord<z.ZodString, z.ZodObject<{
    segmentId: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    segmentId: number;
}, {
    segmentId: number;
}>>;
export type UseSegments = (props: UseSegmentsProps) => UseSegmentsReturn;
export type UseSegmentsProps = {
    tableIdentifier: string;
    providedSegments?: FilterSegmentOutput[];
    systemSegments?: SystemFilterSegment[];
};
export type UseSegmentsReturn = {
    segments: CombinedFilterSegment[];
    preferredSegmentId: SegmentIdentifier | null;
    isSuccess: boolean;
    setPreference: ({ tableIdentifier, segmentId, }: {
        tableIdentifier: string;
        segmentId: SegmentIdentifier | null;
    }) => void;
    isSegmentEnabled: boolean;
};
//# sourceMappingURL=types.d.ts.map