import { z } from "zod";
export declare const ZListFilterSegmentsInputSchema: z.ZodObject<{
    tableIdentifier: z.ZodString;
}, "strip", z.ZodTypeAny, {
    tableIdentifier: string;
}, {
    tableIdentifier: string;
}>;
export type TListFilterSegmentsInputSchema = z.infer<typeof ZListFilterSegmentsInputSchema>;
export declare const ZDeleteFilterSegmentInputSchema: z.ZodObject<{
    id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    id: number;
}, {
    id: number;
}>;
export type TDeleteFilterSegmentInputSchema = z.infer<typeof ZDeleteFilterSegmentInputSchema>;
export declare const ZCreateFilterSegmentInputSchema: z.ZodDiscriminatedUnion<"scope", [z.ZodObject<{
    name: z.ZodString;
    tableIdentifier: z.ZodString;
    activeFilters: z.ZodOptional<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">>;
    sorting: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        desc: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        id: string;
        desc: boolean;
    }, {
        id: string;
        desc: boolean;
    }>, "many">>;
    columnVisibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    columnSizing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    searchTerm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    perPage: z.ZodNumber;
    scope: z.ZodLiteral<"TEAM">;
    teamId: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    name: string;
    teamId: number;
    scope: "TEAM";
    tableIdentifier: string;
    perPage: number;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
}, {
    name: string;
    teamId: number;
    scope: "TEAM";
    tableIdentifier: string;
    perPage: number;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
}>, z.ZodObject<{
    name: z.ZodString;
    tableIdentifier: z.ZodString;
    activeFilters: z.ZodOptional<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">>;
    sorting: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        desc: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        id: string;
        desc: boolean;
    }, {
        id: string;
        desc: boolean;
    }>, "many">>;
    columnVisibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    columnSizing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    searchTerm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    perPage: z.ZodNumber;
    scope: z.ZodLiteral<"USER">;
    teamId: z.ZodOptional<z.ZodUndefined>;
}, "strip", z.ZodTypeAny, {
    name: string;
    scope: "USER";
    tableIdentifier: string;
    perPage: number;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    teamId?: undefined;
}, {
    name: string;
    scope: "USER";
    tableIdentifier: string;
    perPage: number;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    teamId?: undefined;
}>]>;
export type TCreateFilterSegmentInputSchema = z.infer<typeof ZCreateFilterSegmentInputSchema>;
export declare const ZSetFilterSegmentPreferenceInputSchema: z.ZodObject<{
    tableIdentifier: z.ZodString;
    segmentId: z.ZodNullable<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"system">;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "system";
    }, {
        id: string;
        type: "system";
    }>, z.ZodObject<{
        id: z.ZodNumber;
        type: z.ZodLiteral<"user">;
    }, "strip", z.ZodTypeAny, {
        id: number;
        type: "user";
    }, {
        id: number;
        type: "user";
    }>]>>;
}, "strip", z.ZodTypeAny, {
    tableIdentifier: string;
    segmentId: {
        id: string;
        type: "system";
    } | {
        id: number;
        type: "user";
    } | null;
}, {
    tableIdentifier: string;
    segmentId: {
        id: string;
        type: "system";
    } | {
        id: number;
        type: "user";
    } | null;
}>;
export type TSetFilterSegmentPreferenceInputSchema = z.infer<typeof ZSetFilterSegmentPreferenceInputSchema>;
export declare const ZUpdateFilterSegmentInputSchema: z.ZodDiscriminatedUnion<"scope", [z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    tableIdentifier: z.ZodOptional<z.ZodString>;
    activeFilters: z.ZodOptional<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">>;
    sorting: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        desc: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        id: string;
        desc: boolean;
    }, {
        id: string;
        desc: boolean;
    }>, "many">>;
    columnVisibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    columnSizing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    searchTerm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    perPage: z.ZodOptional<z.ZodNumber>;
    id: z.ZodNumber;
    scope: z.ZodLiteral<"TEAM">;
    teamId: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    id: number;
    teamId: number;
    scope: "TEAM";
    name?: string | undefined;
    tableIdentifier?: string | undefined;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    perPage?: number | undefined;
}, {
    id: number;
    teamId: number;
    scope: "TEAM";
    name?: string | undefined;
    tableIdentifier?: string | undefined;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    perPage?: number | undefined;
}>, z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    tableIdentifier: z.ZodOptional<z.ZodString>;
    activeFilters: z.ZodOptional<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">>;
    sorting: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        desc: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        id: string;
        desc: boolean;
    }, {
        id: string;
        desc: boolean;
    }>, "many">>;
    columnVisibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    columnSizing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    searchTerm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    perPage: z.ZodOptional<z.ZodNumber>;
    id: z.ZodNumber;
    scope: z.ZodLiteral<"USER">;
}, "strip", z.ZodTypeAny, {
    id: number;
    scope: "USER";
    name?: string | undefined;
    tableIdentifier?: string | undefined;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    perPage?: number | undefined;
}, {
    id: number;
    scope: "USER";
    name?: string | undefined;
    tableIdentifier?: string | undefined;
    activeFilters?: {
        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;
    }[] | undefined;
    sorting?: {
        id: string;
        desc: boolean;
    }[] | undefined;
    columnVisibility?: Record<string, boolean> | undefined;
    columnSizing?: Record<string, number> | undefined;
    searchTerm?: string | null | undefined;
    perPage?: number | undefined;
}>]>;
export type TUpdateFilterSegmentInputSchema = z.infer<typeof ZUpdateFilterSegmentInputSchema>;
//# sourceMappingURL=filterSegment.type.d.ts.map