umami-compass 0.2.0 → 0.3.0

package/dist/mcp/schemas.d.ts

@@ -13,38 +13,1080 @@ export declare const unitSchema: z.ZodOptional<z.ZodEnum<{
 }>>;
 export declare const pageSchema: z.ZodDefault<z.ZodNumber>;
 export declare const pageSizeSchema: z.ZodDefault<z.ZodNumber>;
+export declare const filterOperatorSchema: z.ZodEnum<{
+    contains: "contains";
+    equals: "equals";
+    is_empty: "is_empty";
+    is_not_empty: "is_not_empty";
+    not_contains: "not_contains";
+    not_equals: "not_equals";
+    not_regex: "not_regex";
+    regex: "regex";
+}>;
 export declare const filtersSchema: z.ZodObject<{
-    browser: z.ZodOptional<z.ZodString>;
-    city: z.ZodOptional<z.ZodString>;
+    browser: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    city: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
     cohort: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    country: z.ZodOptional<z.ZodString>;
-    device: z.ZodOptional<z.ZodString>;
-    distinctId: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    device: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    distinctId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
     eventType: z.ZodOptional<z.ZodNumber>;
-    event: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
     excludeBounce: z.ZodOptional<z.ZodBoolean>;
-    hostname: z.ZodOptional<z.ZodString>;
-    language: z.ZodOptional<z.ZodString>;
-    os: z.ZodOptional<z.ZodString>;
+    hostname: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    language: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    os: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
     match: z.ZodOptional<z.ZodEnum<{
         all: "all";
         any: "any";
     }>>;
-    path: z.ZodOptional<z.ZodString>;
-    query: z.ZodOptional<z.ZodString>;
-    referrer: z.ZodOptional<z.ZodString>;
-    region: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    referrer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    region: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
     segment: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    tag: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    utmCampaign: z.ZodOptional<z.ZodString>;
-    utmContent: z.ZodOptional<z.ZodString>;
-    utmMedium: z.ZodOptional<z.ZodString>;
-    utmSource: z.ZodOptional<z.ZodString>;
-    utmTerm: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmCampaign: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmContent: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmMedium: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmSource: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmTerm: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
 }, z.core.$strict>;
+export declare const TRAFFIC_CHANNELS: readonly ["direct", "paidAds", "referral", "affiliate", "sms", "llm", "organicSearch", "paidSearch", "organicSocial", "paidSocial", "email", "organicShopping", "paidShopping", "organicVideo", "paidVideo"];
+export declare const trafficChannelSchema: z.ZodEnum<{
+    affiliate: "affiliate";
+    direct: "direct";
+    email: "email";
+    llm: "llm";
+    organicSearch: "organicSearch";
+    organicShopping: "organicShopping";
+    organicSocial: "organicSocial";
+    organicVideo: "organicVideo";
+    paidAds: "paidAds";
+    paidSearch: "paidSearch";
+    paidShopping: "paidShopping";
+    paidSocial: "paidSocial";
+    paidVideo: "paidVideo";
+    referral: "referral";
+    sms: "sms";
+}>;
+export declare const segmentedFiltersSchema: z.ZodObject<{
+    browser: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    city: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    cohort: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    country: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    device: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    distinctId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    eventType: z.ZodOptional<z.ZodNumber>;
+    event: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    excludeBounce: z.ZodOptional<z.ZodBoolean>;
+    hostname: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    language: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    os: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    match: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        any: "any";
+    }>>;
+    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    referrer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    region: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    segment: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    tag: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmCampaign: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmContent: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmMedium: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmSource: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    utmTerm: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            is_empty: "is_empty";
+            is_not_empty: "is_not_empty";
+            not_contains: "not_contains";
+            not_equals: "not_equals";
+            not_regex: "not_regex";
+            regex: "regex";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>]>>;
+    channel: z.ZodOptional<z.ZodEnum<{
+        affiliate: "affiliate";
+        direct: "direct";
+        email: "email";
+        llm: "llm";
+        organicSearch: "organicSearch";
+        organicShopping: "organicShopping";
+        organicSocial: "organicSocial";
+        organicVideo: "organicVideo";
+        paidAds: "paidAds";
+        paidSearch: "paidSearch";
+        paidShopping: "paidShopping";
+        paidSocial: "paidSocial";
+        paidVideo: "paidVideo";
+        referral: "referral";
+        sms: "sms";
+    }>>;
+}, z.core.$strict>;
+export declare const trafficSegmentSchema: z.ZodDefault<z.ZodEnum<{
+    all: "all";
+    human: "human";
+}>>;
+export declare function serializeFilters(filters: Record<string, unknown> | undefined): Query;
+export declare function appendReferrerExclusions(filters: Query, domains: readonly string[]): Query;
 export declare function rangeQuery(start: TimeInput, end: TimeInput, maxRangeDays: number, options?: {
     filters?: z.infer<typeof filtersSchema>;
+    serializedFilters?: Query;
     timezone?: string;
     unit?: string;
 }): Query;
@@ -57,6 +1099,7 @@ declare const UNIT_MILLISECONDS: {
 };
 export declare function seriesRangeQuery(start: TimeInput, end: TimeInput, maxRangeDays: number, options?: {
     filters?: z.infer<typeof filtersSchema>;
+    serializedFilters?: Query;
     timezone?: string;
     unit?: keyof typeof UNIT_MILLISECONDS;
     seriesCount?: number;