@calcom/atoms 1.0.74 → 1.0.75

package/dist/packages/features/data-table/lib/context.d.ts

@@ -0,0 +1,132 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { z } from "zod";
+import { type FilterValue } from "./types";
+declare const dataTableFiltersSchema: z.ZodObject<{
+    f: z.ZodString;
+    v: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"single_select">;
+        data: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        type: "single_select";
+    }, {
+        data: string;
+        type: "single_select";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"multi_select">;
+        data: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string[];
+        type: "multi_select";
+    }, {
+        data: string[];
+        type: "multi_select";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        data: z.ZodObject<{
+            operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
+            operand: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        }, {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    }, {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"number">;
+        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: "number";
+    }, {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    f: string;
+    v?: {
+        data: string;
+        type: "single_select";
+    } | {
+        data: string[];
+        type: "multi_select";
+    } | {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    } | {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    } | undefined;
+}, {
+    f: string;
+    v?: {
+        data: string;
+        type: "single_select";
+    } | {
+        data: string[];
+        type: "multi_select";
+    } | {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    } | {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    } | undefined;
+}>;
+type ActiveFilter = z.infer<typeof dataTableFiltersSchema>;
+export type DataTableContextType = {
+    activeFilters: ActiveFilter[];
+    setActiveFilters: (filters: ActiveFilter[]) => void;
+    clearAll: () => void;
+    updateFilter: (columnId: string, value: FilterValue) => void;
+    removeFilter: (columnId: string) => void;
+    displayedExternalFilters: string[];
+    setDisplayedExternalFilters: Dispatch<SetStateAction<string[]>>;
+    removeDisplayedExternalFilter: (key: string) => void;
+};
+export declare const DataTableContext: import("react").Context<DataTableContextType | null>;
+export declare function DataTableProvider({ children }: {
+    children: React.ReactNode;
+}): JSX.Element;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/packages/features/data-table/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/context.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAwC,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AACjG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,SAAS,CAAC;AAEzD,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAC;AAEH,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3D,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,gBAAgB,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;IACpD,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC7D,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAEzC,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,2BAA2B,EAAE,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAChE,6BAA6B,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,gBAAgB,sDAAmD,CAAC;AAEjF,wBAAgB,iBAAiB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,eAkD5E"}

package/dist/packages/features/data-table/lib/resizing.d.ts

@@ -2,8 +2,8 @@ import type { Table } from "@tanstack/react-table";
 type UsePersistentColumnResizingProps<TData> = {
     enabled: boolean;
     table: Table<TData>;
-    name?: string;
+    identifier?: string;
 };
-export declare function usePersistentColumnResizing<TData>({ enabled, table, name, }: UsePersistentColumnResizingProps<TData>): void;
+export declare function usePersistentColumnResizing<TData>({ enabled, table, identifier, }: UsePersistentColumnResizingProps<TData>): void;
 export {};
 //# sourceMappingURL=resizing.d.ts.map

package/dist/packages/features/data-table/lib/resizing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resizing.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/resizing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,uBAAuB,CAAC;AAKtE,KAAK,gCAAgC,CAAC,KAAK,IAAI;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAqBF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,EACjD,OAAO,EACP,KAAK,EACL,IAAI,GACL,EAAE,gCAAgC,CAAC,KAAK,CAAC,QAsCzC"}
+{"version":3,"file":"resizing.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/resizing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,uBAAuB,CAAC;AAKtE,KAAK,gCAAgC,CAAC,KAAK,IAAI;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAqBF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,EACjD,OAAO,EACP,KAAK,EACL,UAAU,GACX,EAAE,gCAAgC,CAAC,KAAK,CAAC,QAsCzC"}

package/dist/packages/features/data-table/lib/server.d.ts

@@ -1,49 +1,177 @@
 import type { FilterValue } from "./types";
-export declare function makeWhereClause(columnName: string, filterValue: FilterValue): {
+type makeWhereClauseProps = {
+    columnName: string;
+    filterValue: FilterValue;
+    json?: true | {
+        path: string[];
+    };
+};
+export declare function makeWhereClause(props: makeWhereClauseProps): {
     [x: string]: {
+        array_contains: string[];
+        path: string[];
+    } | {
+        in: string[];
+        path: string[];
+    } | {
+        array_contains: string[];
+        path?: undefined;
+    } | {
         in: string[];
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     [x: string]: {
         equals: string;
+        path: string[];
+    } | {
+        equals: string;
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     [x: string]: {
         not: string;
+        path: string[];
+    } | {
+        not: string;
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     [x: string]: {
+        string_contains: string;
+        path: string[];
+    } | {
         contains: string;
         mode: string;
+        path: string[];
+    } | {
+        string_contains: string;
+        path?: undefined;
+    } | {
+        contains: string;
+        mode: string;
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     NOT: {
         [x: string]: {
+            string_contains: string;
+            path: string[];
+        } | {
             contains: string;
             mode: string;
+            path: string[];
+        } | {
+            string_contains: string;
+            path?: undefined;
+        } | {
+            contains: string;
+            mode: string;
+            path?: undefined;
         };
     };
 } | {
     [x: string]: {
+        string_starts_with: string;
+        path: string[];
+    } | {
         startsWith: string;
         mode: string;
+        path: string[];
+    } | {
+        string_starts_with: string;
+        path?: undefined;
+    } | {
+        startsWith: string;
+        mode: string;
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     [x: string]: {
+        string_ends_with: string;
+        path: string[];
+    } | {
+        endsWith: string;
+        mode: string;
+        path: string[];
+    } | {
+        string_ends_with: string;
+        path?: undefined;
+    } | {
         endsWith: string;
         mode: string;
+        path?: undefined;
     };
     NOT?: undefined;
 } | {
     NOT: {
         [x: string]: {
             equals: string;
+            path: string[];
+        } | {
+            equals: string;
+            path?: undefined;
         };
     };
+} | {
+    [x: string]: {
+        equals: number;
+        path: string[];
+    } | {
+        equals: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
+} | {
+    [x: string]: {
+        not: number;
+        path: string[];
+    } | {
+        not: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
+} | {
+    [x: string]: {
+        gt: number;
+        path: string[];
+    } | {
+        gt: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
+} | {
+    [x: string]: {
+        gte: number;
+        path: string[];
+    } | {
+        gte: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
+} | {
+    [x: string]: {
+        lt: number;
+        path: string[];
+    } | {
+        lt: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
+} | {
+    [x: string]: {
+        lte: number;
+        path: string[];
+    } | {
+        lte: number;
+        path?: undefined;
+    };
+    NOT?: undefined;
 };
+export {};
 //# sourceMappingURL=server.d.ts.map

package/dist/packages/features/data-table/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsE3E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAQ3C,KAAK,oBAAoB,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,CAAC,EAAE,IAAI,GAAG;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClC,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwI1D"}

package/dist/packages/features/data-table/lib/types.d.ts

@@ -1,8 +1,29 @@
 import { z } from "zod";
+import type { IconName } from "@calcom/ui";
 export declare const ZTextFilterOperator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
 export type TextFilterOperator = z.infer<typeof ZTextFilterOperator>;
-export declare const ZSelectFilterValue: z.ZodArray<z.ZodString, "many">;
-export type SelectFilterValue = z.infer<typeof ZSelectFilterValue>;
+export declare const ZSingleSelectFilterValue: z.ZodObject<{
+    type: z.ZodLiteral<"single_select">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    type: "single_select";
+}, {
+    data: string;
+    type: "single_select";
+}>;
+export type SingleSelectFilterValue = z.infer<typeof ZSingleSelectFilterValue>;
+export declare const ZMultiSelectFilterValue: z.ZodObject<{
+    type: z.ZodLiteral<"multi_select">;
+    data: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: string[];
+    type: "multi_select";
+}, {
+    data: string[];
+    type: "multi_select";
+}>;
+export type MultiSelectFilterValue = z.infer<typeof ZMultiSelectFilterValue>;
 export declare const ZTextFilterValue: z.ZodObject<{
     type: z.ZodLiteral<"text">;
     data: z.ZodObject<{
@@ -29,7 +50,53 @@ export declare const ZTextFilterValue: z.ZodObject<{
     type: "text";
 }>;
 export type TextFilterValue = z.infer<typeof ZTextFilterValue>;
-export declare const ZFilterValue: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodObject<{
+export declare const ZNumberFilterOperator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte"]>;
+export type NumberFilterOperator = z.infer<typeof ZNumberFilterOperator>;
+export declare const ZNumberFilterValue: z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    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: "number";
+}, {
+    data: {
+        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+        operand: number;
+    };
+    type: "number";
+}>;
+export type NumberFilterValue = z.infer<typeof ZNumberFilterValue>;
+export declare const ZFilterValue: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"single_select">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    type: "single_select";
+}, {
+    data: string;
+    type: "single_select";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"multi_select">;
+    data: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: string[];
+    type: "multi_select";
+}, {
+    data: string[];
+    type: "multi_select";
+}>, z.ZodObject<{
     type: z.ZodLiteral<"text">;
     data: z.ZodObject<{
         operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
@@ -53,12 +120,181 @@ export declare const ZFilterValue: z.ZodUnion<[z.ZodArray<z.ZodString, "many">,
         operand: string;
     };
     type: "text";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    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: "number";
+}, {
+    data: {
+        operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+        operand: number;
+    };
+    type: "number";
 }>]>;
 export type FilterValue = z.infer<typeof ZFilterValue>;
+export type ColumnFilterType = "single_select" | "multi_select" | "text" | "number";
+export type ColumnFilterMeta = {
+    type?: ColumnFilterType;
+    icon?: IconName;
+};
 export type FilterableColumn = {
     id: string;
     title: string;
-    filterType: "text" | "select";
-    options: Map<string, number>;
+} & ({
+    type: "single_select";
+    icon?: IconName;
+    options: Map<string | {
+        label: string;
+        value: string;
+    }, number>;
+} | {
+    type: "multi_select";
+    icon?: IconName;
+    options: Map<string | {
+        label: string;
+        value: string;
+    }, number>;
+} | {
+    type: "text";
+    icon?: IconName;
+} | {
+    type: "number";
+    icon?: IconName;
+});
+export declare const ZColumnFilter: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"single_select">;
+        data: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        type: "single_select";
+    }, {
+        data: string;
+        type: "single_select";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"multi_select">;
+        data: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string[];
+        type: "multi_select";
+    }, {
+        data: string[];
+        type: "multi_select";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        data: z.ZodObject<{
+            operator: z.ZodEnum<["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "isEmpty", "isNotEmpty"]>;
+            operand: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        }, {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    }, {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"number">;
+        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: "number";
+    }, {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        data: string;
+        type: "single_select";
+    } | {
+        data: string[];
+        type: "multi_select";
+    } | {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    } | {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    };
+    id: string;
+}, {
+    value: {
+        data: string;
+        type: "single_select";
+    } | {
+        data: string[];
+        type: "multi_select";
+    } | {
+        data: {
+            operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
+            operand: string;
+        };
+        type: "text";
+    } | {
+        data: {
+            operator: "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
+            operand: number;
+        };
+        type: "number";
+    };
+    id: string;
+}>;
+export type ColumnFilter = z.infer<typeof ZColumnFilter>;
+export type TypedColumnFilter<T extends ColumnFilterType> = {
+    id: string;
+    value: T extends "text" ? TextFilterValue : T extends "number" ? NumberFilterValue : T extends "single_select" ? SingleSelectFilterValue : T extends "multi_select" ? MultiSelectFilterValue : never;
+};
+export type ExternalFilter = {
+    key: string;
+    titleKey: string;
+    component: () => React.ReactNode;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/packages/features/data-table/lib/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB,kHAS9B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,eAAO,MAAM,kBAAkB,iCAAsB,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEnE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;IAAkD,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../features/data-table/lib/types.ts"],"names":[],"mappings":"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"}