@dx-do/client 5.2.48 → 5.2.50

package/dist/src/lib/model/datastore/tas/filters.d.ts

@@ -0,0 +1,780 @@
+import { z } from 'zod/v4';
+/**
+ * Comparison operator on an `AttributeExpression`. `IN` / `NOT_IN` test set
+ * membership against `values[]`; `MATCHES` / `NOT_MATCHES` apply the strings
+ * as Java regex patterns; `GE`/`GT`/`LE`/`LT` compare against the *first*
+ * element of `values[]` using the configured `comparator`.
+ */
+export declare const AttributeExpressionOperatorSchema: z.ZodEnum<{
+    IN: "IN";
+    NOT_IN: "NOT_IN";
+    MATCHES: "MATCHES";
+    NOT_MATCHES: "NOT_MATCHES";
+    GE: "GE";
+    GT: "GT";
+    LE: "LE";
+    LT: "LT";
+}>;
+/**
+ * Comparator for ordered (`GE`/`GT`/`LE`/`LT`) attribute comparisons.
+ * `LEXICAL` is the default. `NUMBER` parses both sides as integers; `DATETIME`
+ * parses both sides as ISO 8601. Non-parsable values silently fail to match.
+ * Ignored by `IN`/`NOT_IN`/`MATCHES`/`NOT_MATCHES`.
+ */
+export declare const AttributeExpressionComparatorSchema: z.ZodEnum<{
+    LEXICAL: "LEXICAL";
+    NUMBER: "NUMBER";
+    DATETIME: "DATETIME";
+}>;
+/**
+ * A single attribute predicate inside an `ATTRIBUTE` filter (or any
+ * `expressions[]` array on a traversal vertex/edge filter). All expressions
+ * in an `expressions[]` array are AND-ed together; the `values[]` within a
+ * single expression are OR-ed (under `IN`/`MATCHES`) or used positionally
+ * (`GE`/`GT`/`LE`/`LT` use only the first element).
+ */
+export declare const AttributeExpressionSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    pointer: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    operator: z.ZodOptional<z.ZodEnum<{
+        IN: "IN";
+        NOT_IN: "NOT_IN";
+        MATCHES: "MATCHES";
+        NOT_MATCHES: "NOT_MATCHES";
+        GE: "GE";
+        GT: "GT";
+        LE: "LE";
+        LT: "LT";
+    }>>;
+    layer: z.ZodOptional<z.ZodString>;
+    comparator: z.ZodOptional<z.ZodEnum<{
+        LEXICAL: "LEXICAL";
+        NUMBER: "NUMBER";
+        DATETIME: "DATETIME";
+    }>>;
+    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type AttributeExpression = z.infer<typeof AttributeExpressionSchema>;
+/**
+ * Per-attribute projection rule used by `TasProjectionFilter`. Plucks a
+ * sub-value out of a structured attribute (via `pointer`, JSON Pointer
+ * RFC 6901) and re-emits it on each vertex/edge under the new field name
+ * `as`. Example: lift `Company./geopoint/lat` to a top-level
+ * `geopoint.lat` field.
+ */
+export declare const AttributeValueAsFieldSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    pointer: z.ZodOptional<z.ZodString>;
+    as: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type AttributeValueAsField = z.infer<typeof AttributeValueAsFieldSchema>;
+/**
+ * Per-step vertex filter applied to the *remote* vertex discovered by an
+ * edge during TRAVERSE. Recognized ops: `ALL` (always pass), `NONE` (always
+ * fail), `AND`/`OR`/`NOT` (composition), `ATTRIBUTE` (expressions match,
+ * see `AttributeExpressionSchema`), `LAYER` (single `value` or `values[]`),
+ * `VERTEX` (by id or externalId).
+ *
+ * Loose object on purpose — the discriminated union is not enforced here so
+ * any of the per-op shapes serializes cleanly.
+ */
+export declare const TraversalVertexFilterSchema: z.ZodType<TraversalVertexFilter>;
+export type TraversalVertexFilter = {
+    op?: string;
+    input?: TraversalVertexFilter[];
+    expressions?: AttributeExpression[];
+    layer?: string;
+    values?: string[];
+    vertexId?: number[];
+    [key: string]: unknown;
+};
+/**
+ * Per-step edge filter applied to each candidate edge during TRAVERSE.
+ * Recognized ops: `ALL`, `NONE`, `AND`/`OR`/`NOT`, `ATTRIBUTE`,
+ * `FLOW` (matches edges whose `flow_id` is in the result of the nested
+ * TAS filter passed via the wire field `flows`), and
+ * `FOLLOW` with `followToLayers[]` (cross-layer edge selector; supports
+ * the pseudo-layers `_SELF_` and `_NOT_SELF_`).
+ */
+export declare const TraversalEdgeFilterSchema: z.ZodType<TraversalEdgeFilter>;
+export type TraversalEdgeFilter = {
+    op?: string;
+    input?: TraversalEdgeFilter[];
+    expressions?: AttributeExpression[];
+    flowFilter?: string[];
+    [key: string]: unknown;
+};
+/**
+ * Direction an edge is traversed at a given TRAVERSE step. `FORWARD`
+ * (default) walks edges from source -> target; `BACKWARD` walks
+ * target -> source; `ANY` ignores direction.
+ */
+export declare const TraverseDirectionSchema: z.ZodEnum<{
+    ANY: "ANY";
+    FORWARD: "FORWARD";
+    BACKWARD: "BACKWARD";
+}>;
+/**
+ * What a TRAVERSE step collects into the result. `ALL` (default) collects
+ * both the discovered edge and the discovered vertex; `EDGE` keeps only
+ * the edge; `VERTEX` keeps only the discovered vertex; `NONE` keeps
+ * nothing (used as a guard step that just enforces existence of a path).
+ */
+export declare const TraverseCollectSchema: z.ZodEnum<{
+    ALL: "ALL";
+    EDGE: "EDGE";
+    VERTEX: "VERTEX";
+    NONE: "NONE";
+}>;
+/**
+ * One step in a `TRAVERSE` filter's `traverse[]` recipe. Each step matches
+ * a single hop along the graph. Steps can be chained via `next[]` to build
+ * multi-hop traversals where each hop has independent filters/direction.
+ *
+ * Defaults: `direction=FORWARD`, `collect=ALL`, `repeat=1`,
+ * `repeatMin=repeat` (unless explicitly set; `repeatMin=-1` is a sentinel
+ * meaning "same as repeat"). When `optional=true` the step works like a
+ * left-outer join — paths that don't satisfy this step are still emitted.
+ */
+export declare const TraverseSchema: z.ZodType<Traverse>;
+export type Traverse = {
+    edgeFilter?: TraversalEdgeFilter;
+    vertexFilter?: TraversalVertexFilter;
+    collect?: z.infer<typeof TraverseCollectSchema>;
+    direction?: z.infer<typeof TraverseDirectionSchema>;
+    repeatMin?: number;
+    repeat?: number;
+    optional?: boolean;
+    next?: Traverse[];
+    [key: string]: unknown;
+};
+/**
+ * A grouping dimension pairing an attribute name with an optional layer scope.
+ * Used by COLLECT_GROUPING_INFO (as a list) and COLLECT_CARD_INFO (as a single
+ * item).
+ *
+ * Note: the JSON field for the attribute name is serialized as `name`.
+ */
+export declare const TasGroupingItemSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type TasGroupingItem = z.infer<typeof TasGroupingItemSchema>;
+/**
+ * `ATTRIBUTE` filter behavior. Default is `VERTEX_AND_RELATED_EDGES` —
+ * match vertices, then keep edges referencing those vertices.
+ *
+ * - `VERTEX_AND_RELATED_EDGES` — match vertices, keep related edges (default)
+ * - `EDGE_AND_RELATED_VERTICES` — match edges, keep related vertices
+ * - `VERTEX_ONLY` — match vertices; keep all edges from input untouched
+ * - `EDGE_ONLY` — match edges; keep all vertices from input untouched
+ */
+export declare const TasAttributeFilterModeSchema: z.ZodEnum<{
+    VERTEX_AND_RELATED_EDGES: "VERTEX_AND_RELATED_EDGES";
+    EDGE_AND_RELATED_VERTICES: "EDGE_AND_RELATED_VERTICES";
+    VERTEX_ONLY: "VERTEX_ONLY";
+    EDGE_ONLY: "EDGE_ONLY";
+}>;
+/**
+ * Direction modes for `FOLLOW_PATH`.
+ *
+ * - `DOWN` — outgoing edges only
+ * - `UP` — incoming edges only
+ * - `BOTH` — both directions in parallel
+ * - `UP_THEN_DOWN` — first traverse incoming, then outgoing from the covered set
+ * - `DOWN_THEN_UP` — first outgoing, then incoming from the covered set
+ * - `FULL` — any direction without upstream/downstream tracking
+ * - `COVERAGE` — additive variant of `COVERAGE` filter (input + flow coverage)
+ */
+export declare const TasFollowPathTypeSchema: z.ZodEnum<{
+    BOTH: "BOTH";
+    DOWN: "DOWN";
+    UP: "UP";
+    UP_THEN_DOWN: "UP_THEN_DOWN";
+    DOWN_THEN_UP: "DOWN_THEN_UP";
+    FULL: "FULL";
+    COVERAGE: "COVERAGE";
+}>;
+/**
+ * Flow-attribute selector applied to edges by `FOLLOW_PATH`. Combine
+ * multiple values to OR them.
+ *
+ * - `UNDEFINED_FLOW` — edges with no `flow_id`
+ * - `DEFINED_FLOW` — edges with a `flow_id`
+ * - `FLOW_FROM_INPUT` — edges whose `flow_id` matches a flow vertex in the input
+ */
+export declare const TasFollowPathFlowFilterSchema: z.ZodEnum<{
+    UNDEFINED_FLOW: "UNDEFINED_FLOW";
+    DEFINED_FLOW: "DEFINED_FLOW";
+    FLOW_FROM_INPUT: "FLOW_FROM_INPUT";
+}>;
+/**
+ * `JOIN` filter behavior. Cross-layer relational join between `input` (left)
+ * and `rightInput` (right) where the join key is a cross-layer edge.
+ *
+ * - `LEFT` (default if omitted) — all of input + matching right rows
+ * - `RIGHT` — all of rightInput + matching left rows
+ * - `INNER` — only topology with cross-layer joins
+ * - `NOT` — anti-join (Java-side support; not in public AsciiDoc)
+ */
+export declare const TasJoinTypeSchema: z.ZodEnum<{
+    LEFT: "LEFT";
+    INNER: "INNER";
+    RIGHT: "RIGHT";
+    NOT: "NOT";
+}>;
+/**
+ * Topology tier targeted by COLLECT_CARD_INFO. Default (when omitted on the
+ * Java side) is `ANY_ATC`. EXPERIENCE / FRONTEND / DATABASE / BACKEND select
+ * specific APM tiers; AGENT targets agents.
+ */
+export declare const TasCollectCardInfoTierSchema: z.ZodEnum<{
+    EXPERIENCE: "EXPERIENCE";
+    FRONTEND: "FRONTEND";
+    DATABASE: "DATABASE";
+    BACKEND: "BACKEND";
+    ANY_ATC: "ANY_ATC";
+    AGENT: "AGENT";
+}>;
+/**
+ * Scope selector for COLLECT_EXPERIENCE_ATTRIBUTES. EXPERIENCE targets
+ * vertices with `IsExperience=Yes`; BT targets vertices with
+ * `type=BUSINESSTRANSACTION`.
+ */
+export declare const TasCollectExperienceSelectorSchema: z.ZodEnum<{
+    EXPERIENCE: "EXPERIENCE";
+    BT: "BT";
+}>;
+/**
+ * `ALL` — returns the full topology. The default base set when no other
+ * source is specified. Has no `input`.
+ */
+export declare const TasAllFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+}, z.core.$loose>;
+/**
+ * `EMPTY` — returns an empty result (no vertices, no edges). Useful when
+ * you want analytic results only (paired with COLLECT_* filters that
+ * accumulate side-channel results into `analytics[]`).
+ */
+export declare const TasEmptyFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"EMPTY">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `AND` — logical intersection. A vertex/edge is kept only if it appears
+ * in *every* `input[]` child's result.
+ *
+ * The Zod schema enforces `min(1)` because the server returns a 400 for
+ * empty AND composites.
+ */
+export declare const TasAndFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"AND">;
+    input: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>>;
+}, z.core.$loose>;
+/**
+ * `OR` — logical union. A vertex/edge is kept if it appears in *any*
+ * `input[]` child's result.
+ *
+ * The Zod schema enforces `min(1)` because the server returns a 400 for
+ * empty OR composites.
+ */
+export declare const TasOrFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"OR">;
+    input: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>>;
+}, z.core.$loose>;
+/**
+ * `NOT` — logical complement. Returns everything *not* in `input`'s result.
+ * Almost always used inside an `AND` to subtract — a top-level `NOT` over
+ * `ALL` would attempt to scan the entire negation space.
+ */
+export declare const TasNotFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NOT">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `ATTRIBUTE` — the workhorse selector. Returns vertices (and related
+ * elements per `mode`) matching all of the listed attribute expressions.
+ *
+ * Multiple expressions in `expressions[]` are AND-ed; multiple `values`
+ * inside one expression are OR-ed (or used positionally for ordered
+ * comparisons). See [`AttributeExpressionSchema`].
+ *
+ * Common mistake: writing `expression: { ... }` (singular) instead of
+ * `expressions: [{ ... }]` — the singular form is silently ignored
+ * by the server and returns an empty result.
+ */
+export declare const TasAttributeFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ATTRIBUTE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    expressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        pointer: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        operator: z.ZodOptional<z.ZodEnum<{
+            IN: "IN";
+            NOT_IN: "NOT_IN";
+            MATCHES: "MATCHES";
+            NOT_MATCHES: "NOT_MATCHES";
+            GE: "GE";
+            GT: "GT";
+            LE: "LE";
+            LT: "LT";
+        }>>;
+        layer: z.ZodOptional<z.ZodString>;
+        comparator: z.ZodOptional<z.ZodEnum<{
+            LEXICAL: "LEXICAL";
+            NUMBER: "NUMBER";
+            DATETIME: "DATETIME";
+        }>>;
+        caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    layer: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        VERTEX_AND_RELATED_EDGES: "VERTEX_AND_RELATED_EDGES";
+        EDGE_AND_RELATED_VERTICES: "EDGE_AND_RELATED_VERTICES";
+        VERTEX_ONLY: "VERTEX_ONLY";
+        EDGE_ONLY: "EDGE_ONLY";
+    }>>;
+}, z.core.$loose>;
+/**
+ * `TRAVERSE` — graph traversal from a starting vertex set. Each `traverse[]`
+ * entry is one hop with its own filters/direction; entries can chain via
+ * `Traverse.next[]` for multi-hop paths.
+ *
+ * If `traverse` is omitted, returns the direct first-level descendants
+ * of the input plus their connecting edges. `includeInput=true` includes
+ * the starting vertices in the result; `collectStart=false` drops them.
+ */
+export declare const TasTraverseFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"TRAVERSE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    traverse: z.ZodOptional<z.ZodArray<z.ZodType<Traverse, unknown, z.core.$ZodTypeInternals<Traverse, unknown>>>>;
+    collectStart: z.ZodOptional<z.ZodBoolean>;
+    includeInput: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `VERTEX` — selects vertices by numeric `vertexId[]` or string
+ * `externalId[]`, plus their adjacent edges. `not=true` inverts the match
+ * (return everything not in the listed ids).
+ *
+ * Note: the wire `op` value `"VERTEX"` is shared with `TasVariableFilter`
+ * — distinguish by whether `name` (variable reference) or `vertexId` /
+ * `externalId` is present.
+ */
+export declare const TasVertexIdFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"VERTEX">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    vertexId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    externalId: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `SERVICE` — restricts to vertices / adjacent edges associated with the
+ * named services (and, by default, all sub-services in the service
+ * hierarchy as defined in the Service Definition).
+ *
+ * Toggle `excludeSubServices=true` for an exact-service-only match;
+ * `includeServiceHierarchy=true` includes higher-level service ancestors
+ * in addition to descendants.
+ */
+export declare const TasServiceFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"SERVICE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    includeServiceHierarchy: z.ZodOptional<z.ZodBoolean>;
+    excludeSubServices: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `LUCENE` — Lucene-syntax full-text query against vertex attributes.
+ * Technically a variant of ATTRIBUTE; not all Lucene features are
+ * supported. Adjacent edges are included.
+ *
+ * Gotcha: requires the tenant to have Lucene indexing enabled. Where it
+ * is not enabled the API returns 400 with a query-parser error. Mark
+ * such queries `expectedFailure: true` in test metadata.
+ */
+export declare const TasLuceneFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"LUCENE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    query: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * `LAYER` — restricts the topology to a specific layer (or layers).
+ * Provide either a single `value` or a `values[]` array (OR-ed). Layer
+ * names follow the convention of the first segment of `externalId`
+ * (e.g. `ATC`, `INFRASTRUCTURE`, `APM_INFRASTRUCTURE`); discover the
+ * actual set on a tenant via the discovery query that excludes known
+ * layer names.
+ */
+export declare const TasLayerFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"LAYER">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    value: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+/**
+ * `JOIN` — relational-style cross-layer join between two filter results.
+ * The left side is `input`; the right side is `rightInput` (defaults to
+ * ALL). Foreign vertices are pulled in when there is a cross-layer edge
+ * between an `input` vertex and a `rightInput` vertex.
+ *
+ * Default `type` is `LEFT`. See `TasJoinTypeSchema` for the variants.
+ * For "single-layer foreign join" use `LAYER` instead — this op is for
+ * arbitrary filter-vs-filter joins.
+ */
+export declare const TasJoinFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"JOIN">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        LEFT: "LEFT";
+        INNER: "INNER";
+        RIGHT: "RIGHT";
+        NOT: "NOT";
+    }>>;
+    rightInput: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `FOLLOW_PATH` — directional path-following with hop limits and flow
+ * filtering. Used for "upstream / downstream / dependency" queries. By
+ * default follows edges only on the same layer as their source; widen via
+ * `followToLayers[]` (which supports the pseudo-layer tokens `_SELF_`
+ * and `_NOT_SELF_`).
+ *
+ * `upHops` / `downHops` cap traversal depth; defaults are infinite.
+ * `flowFilter[]` further narrows by edge `flow_id` semantics.
+ */
+export declare const TasFollowPathFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"FOLLOW_PATH">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        BOTH: "BOTH";
+        DOWN: "DOWN";
+        UP: "UP";
+        UP_THEN_DOWN: "UP_THEN_DOWN";
+        DOWN_THEN_UP: "DOWN_THEN_UP";
+        FULL: "FULL";
+        COVERAGE: "COVERAGE";
+    }>>;
+    upHops: z.ZodOptional<z.ZodNumber>;
+    downHops: z.ZodOptional<z.ZodNumber>;
+    flowFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        UNDEFINED_FLOW: "UNDEFINED_FLOW";
+        DEFINED_FLOW: "DEFINED_FLOW";
+        FLOW_FROM_INPUT: "FLOW_FROM_INPUT";
+    }>>>;
+    followToLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+/**
+ * `COVERAGE` — given flow vertices in `input`, returns the full flow
+ * coverage (every vertex/edge sharing the same flow). Use `FOLLOW_PATH`
+ * with `type=COVERAGE` for an additive variant that includes the input
+ * graph alongside the coverage.
+ *
+ * @see TasAddFlowsFilterSchema — only adds flow + input rather than all coverage
+ */
+export declare const TasCoverageFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COVERAGE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `STATUS` — restricts the input set by current vertex state (alerts,
+ * metrics, etc.). The `statusFilter` is a `VertexStateFilter` discriminated
+ * union owned by the states API; the same payload type can also be passed
+ * via the top-level `TasQuery.stateFilter` field.
+ *
+ * Not in the public AsciiDoc reference; used by dashboards that need to
+ * scope topology by alert / metric state.
+ */
+export declare const TasStatusFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"STATUS">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    statusFilter: z.ZodOptional<z.ZodType<import("../states").VertexStateFilter, unknown, z.core.$ZodTypeInternals<import("../states").VertexStateFilter, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `VARIABLE` — references a sub-filter declared in the top-level
+ * `TasQuery.variables[]` array by name. Lets the same intermediate
+ * result be reused in multiple places without recomputation.
+ *
+ * Note: shares `op="VERTEX"` semantics on the wire? No — the wire op
+ * is literally `"VARIABLE"`. (Java's `TasVariableFilter.toString` says
+ * "VERTEX" but the JSON discriminator is `VARIABLE`.)
+ */
+export declare const TasVariableFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"VARIABLE">;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * `LEGACY` — escape hatch for legacy filter shapes the discriminated
+ * union does not yet model. The `legacy` payload is passed through to
+ * the server unchanged. Avoid in new code.
+ */
+export declare const TasLegacyFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"LEGACY">;
+    legacy: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+/**
+ * `ADD_FLOWS` — augments the input by adding the flow-owner vertex
+ * (transaction, entry-point) for every edge that has a `flow` attribute.
+ * Use to make flow attribution visible in the response without changing
+ * which edges are returned.
+ */
+export declare const TasAddFlowsFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ADD_FLOWS">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    includeJoined: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `ADD_WIRES` — augments the input with wire information for the matched
+ * vertices/edges. Not in the public AsciiDoc reference.
+ */
+export declare const TasAddWiresFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ADD_WIRES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    considerIncompleteEdges: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `ADD_WIRE_CONTEXT` — for each input vertex, add the edges (and
+ * optionally the source/target vertices) where that vertex appears as a
+ * wire. Toggle `addEdges` / `addSourceVertices` / `addTargetVertices`
+ * to control breadth (all default to true).
+ */
+export declare const TasAddWireContextFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ADD_WIRE_CONTEXT">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    addEdges: z.ZodOptional<z.ZodBoolean>;
+    addSourceVertices: z.ZodOptional<z.ZodBoolean>;
+    addTargetVertices: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `ADD_TRANSITIONING_EDGES` — when an upstream filter (e.g. ATTRIBUTE)
+ * cuts the graph into disconnected sub-graphs, this filter synthesizes
+ * the missing edges that *would* have connected them in the full graph.
+ * Synthesized edges are tagged with attribute `virtual="true"`.
+ *
+ * Most commonly used as a `postFilter` of a `TasQuery` after `filter`
+ * and `universe` have been applied.
+ */
+export declare const TasAddTransitioningEdgesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ADD_TRANSITIONING_EDGES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `TAKE_VERTICES` — projects the input down to only its vertices.
+ * Discards all edges. Useful as the outermost wrapper when only the
+ * vertex set matters.
+ */
+export declare const TasTakeVerticesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"TAKE_VERTICES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `TAKE_EDGES` — projects the input down to only its edges. Common
+ * pattern: wrap a `TRAVERSE` to extract the edges *between* two vertex
+ * sets without the vertices themselves.
+ */
+export declare const TasTakeEdgesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"TAKE_EDGES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `TAKE_FLOWS` — returns only the vertices that appear as `flow` on one
+ * of the input's edges (the flow owners — typically transactions or
+ * entry-points).
+ */
+export declare const TasTakeFlowsFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"TAKE_FLOWS">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * COLLECT_ATTRIBUTES — analytic pass-through filter.
+ *
+ * Passes the input graph through unchanged and collects all distinct values
+ * for the named attribute across the matched vertices. The result is returned
+ * in `response.analytics[]` keyed by `id`.
+ *
+ * Primary use: populate combo-box options in a query-builder UI. Stack
+ * multiple instances in one query (as siblings inside AND/OR) to fill all
+ * dropdowns in a single round-trip.
+ *
+ * Response entry type: `TasCollectAttributeResult`
+ *   `{ id, values: [{ attribValue, occurances, vertexIds? }] }`
+ *
+ * @see TasCollectAttributeNamesFilterSchema — discover what attribute names exist
+ * @see TasCollectExperienceAttributesFilterSchema — APM/BT-scoped variant
+ */
+export declare const TasCollectAttributesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_ATTRIBUTES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+    attributeName: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+    includeIds: z.ZodOptional<z.ZodBoolean>;
+    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    skipBackends: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * COLLECT_ATTRIBUTE_NAMES — analytic pass-through filter.
+ *
+ * Collects the distinct attribute *names* (keys) present on vertices in the
+ * input, rather than their values. Useful for discovering what attributes
+ * exist on a given layer before authoring an ATTRIBUTE filter.
+ *
+ * Response entry type: `TasCollectAttributeNamesResult`
+ *   `{ id, values: [{ name, layer, type: TasAttributeType }] }`
+ */
+export declare const TasCollectAttributeNamesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_ATTRIBUTE_NAMES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * COLLECT_COUNTS — analytic pass-through filter.
+ *
+ * Counts the vertices matched by the input filter at this stage of the
+ * query pipeline. Useful for tracking how many vertices survive each
+ * progressive filter stage without issuing separate queries.
+ *
+ * Response entry type: `TasCollectCountsResult`
+ *   `{ id, vertexCount: number }`
+ */
+export declare const TasCollectCountsFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_COUNTS">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * COLLECT_VERTEX_ID — analytic pass-through filter.
+ *
+ * Collects the numeric vertex IDs of all vertices in the input. Typically
+ * used to capture a stable vertex-id snapshot from one query stage for use
+ * in a subsequent VERTEX id-based filter or external lookup.
+ *
+ * Response entry type: `TasCollectVertexIdResult`
+ *   `{ id, vertexIds: number[] }`
+ */
+export declare const TasCollectVertexIdFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_VERTEX_ID">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+    skipBackends: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * COLLECT_GROUPING_INFO — analytic post-filter.
+ *
+ * Groups vertices in the input by one or more attribute/layer dimensions and
+ * returns per-group aggregated statistics (vertex IDs, alert / caution /
+ * danger counts). Implemented as a *post-filter* on the Java side — applied
+ * after the main `filter` and `universe` have been resolved. Used by
+ * dashboard "group-by" widgets.
+ *
+ * Response entry type: `TasCollectGroupingInfoResult`
+ *   `{ id, values: [{ id, name, groupName, layer, vertexIds, alertStatistics }] }`
+ */
+export declare const TasCollectGroupingInfoFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_GROUPING_INFO">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+    grouping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        layer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/**
+ * COLLECT_CARD_INFO — analytic pass-through filter.
+ *
+ * Collects "card" display information for a specific topology tier, grouped
+ * by a single attribute/layer dimension. Designed for rendering UI summary
+ * cards (one card per distinct attribute value). Optionally includes full
+ * vertex attribute data via `includeVertexInfo`.
+ *
+ * Response entry type: `TasCollectCardInfoResult`
+ *   `{ name, vertexIds, values?: AtcVertexBaseInfo[] }`
+ *
+ * The `tier` field selects which tier of the APM topology to target:
+ *   `EXPERIENCE | FRONTEND | DATABASE | BACKEND | ANY_ATC (default) | AGENT`.
+ */
+export declare const TasCollectCardInfoFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_CARD_INFO">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        EXPERIENCE: "EXPERIENCE";
+        FRONTEND: "FRONTEND";
+        DATABASE: "DATABASE";
+        BACKEND: "BACKEND";
+        ANY_ATC: "ANY_ATC";
+        AGENT: "AGENT";
+    }>>;
+    grouping: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        layer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    includeVertexInfo: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * COLLECT_EXPERIENCE_ATTRIBUTES — APM/BT-scoped analytic pass-through filter.
+ *
+ * Works identically to COLLECT_ATTRIBUTES but restricts collection to APM
+ * experience vertices (`IsExperience=Yes`) or business-transaction vertices
+ * (`type=BUSINESSTRANSACTION`), controlled by `selector`.
+ *
+ * Response entry type: same as COLLECT_ATTRIBUTES —
+ *   `TasCollectAttributeResult { id, values: [{ attribValue, occurances, vertexIds? }] }`
+ *
+ * @see TasCollectAttributesFilterSchema — general (non-APM) variant
+ */
+export declare const TasCollectExperienceAttributesFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_EXPERIENCE_ATTRIBUTES">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+    id: z.ZodOptional<z.ZodString>;
+    attributeName: z.ZodOptional<z.ZodString>;
+    layer: z.ZodOptional<z.ZodString>;
+    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    selector: z.ZodOptional<z.ZodEnum<{
+        EXPERIENCE: "EXPERIENCE";
+        BT: "BT";
+    }>>;
+}, z.core.$loose>;
+export declare const TasFilterSchema: z.ZodType<TasFilter>;
+export interface TasFilter {
+    op: string;
+    [key: string]: unknown;
+}
+/**
+ * A named sub-filter declared at the top of `TasQuery.variables[]`.
+ * Reference it elsewhere in the filter tree via
+ * `{ "op": "VARIABLE", "name": "<name>" }`. Useful when the same
+ * intermediate result needs to be reused (e.g. a base set + its
+ * neighborhood) without recomputation.
+ */
+export declare const TasVariableSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<TasFilter, unknown, z.core.$ZodTypeInternals<TasFilter, unknown>>>>;
+}, z.core.$loose>;
+export type TasVariable = z.infer<typeof TasVariableSchema>;
+/**
+ * Projection filter applied to the response — restricts which vertex/edge
+ * attributes appear, and optionally lifts JSON-Pointer-addressed sub-values
+ * to top-level fields.
+ *
+ * - `attributes[]` — whitelist of attribute names to keep
+ * - `attributeValueAsFields[]` — synthetic fields produced by extracting
+ *   pointer paths out of structured attributes (see `AttributeValueAsField`).
+ *
+ * Mutually compatible with the coarser `TasQuery.projection` enum
+ * (`DETAILED` / `BRIEF` / `NO_TYPE`).
+ */
+export declare const TasProjectionFilterSchema: z.ZodObject<{
+    attributes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attributeValueAsFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        pointer: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type TasProjectionFilter = z.infer<typeof TasProjectionFilterSchema>;
+//# sourceMappingURL=filters.d.ts.map