@raft-tech/rdp-sdk-typescript 2026.26.0

package/dist/gen/raft/wdm/v1/service/query_pb.d.ts

@@ -0,0 +1,1602 @@
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { ActionPriority, ActionScope, ActionState } from "../action_pb.js";
+import type { Affiliation, Environment } from "../assessment_pb.js";
+import type { Principal } from "../common_pb.js";
+import type { ObjectStatus } from "../object_pb.js";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file raft/wdm/v1/service/query.proto.
+ */
+export declare const file_raft_wdm_v1_service_query: GenFile;
+/**
+ * Query criteria for retrieving actions from storage.
+ *
+ * Uses a flat structure where all criteria are combined with AND logic between
+ * fields, and OR logic within repeated fields. Optimized for efficient bulk
+ * retrieval. Empty query returns all actions.
+ *
+ * Logic semantics:
+ *   - Multiple values within a repeated field use OR (e.g., states=[1,2] means
+ *     state=DRAFT OR state=PENDING)
+ *   - Different fields are combined with AND (e.g., states=[7] AND priorities=[3])
+ *
+ * Scope semantics:
+ *   - The `scopes` field filters on Action.scope (ACTION_SCOPE_TASK, ORDER,
+ *     ALERT, REPORT, PHASE, SUB_TASK, DIRECTIVE, PLAN). Multiple scopes use OR
+ *     and combine with AND against the rest of the query. Omit to include all
+ *     scopes.
+ *
+ * Examples:
+ *
+ * **Query high-priority in-progress actions:**
+ * ```
+ * {
+ *   "states": [7],
+ *   "priorities": [3]
+ * }
+ * ```
+ * Matches: `state=IN_PROGRESS AND priority=HIGH`
+ *
+ * **Query actions assigned to specific principals:**
+ * ```
+ * {
+ *   "assigned_to": [
+ *     {"id": "unit-123", "type": "PRINCIPAL_TYPE_OBJECT"}
+ *   ]
+ * }
+ * ```
+ *
+ * **Query pending or approved fire missions:**
+ * ```
+ * {
+ *   "states": [2, 3],
+ *   "type": ["fire_mission"]
+ * }
+ * ```
+ * Matches: `(state=PENDING OR state=APPROVED) AND type="fire_mission"`
+ *
+ * **Query alerts and reports:**
+ * ```
+ * {
+ *   "scopes": [7, 8]
+ * }
+ * ```
+ * Matches: `scope=ALERT OR scope=REPORT`
+ *
+ * **Query actions of type ISR Collection where details.sensor_type is "EO":**
+ * ```
+ * {
+ *   "type": ["isr_collection"],
+ *   "filter": {
+ *     "actionPredicate": {
+ *       "field": {
+ *         "fieldPath": "details.sensor_type",
+ *         "comparator": "FIELD_COMPARATOR_EQ",
+ *         "value": { "stringValue": "EO" }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ * Matches: `type="isr_collection" AND details.sensor_type == "EO"`
+ *
+ * **Query actions where details.sensor is EO or IR, and details.priority > 5:**
+ * ```
+ * {
+ *   "filter": {
+ *     "and": {
+ *       "statements": [
+ *         {
+ *           "or": {
+ *             "statements": [
+ *               {
+ *                 "actionPredicate": {
+ *                   "field": {
+ *                     "fieldPath": "details.sensor",
+ *                     "comparator": "FIELD_COMPARATOR_EQ",
+ *                     "value": { "stringValue": "EO" }
+ *                   }
+ *                 }
+ *               },
+ *               {
+ *                 "actionPredicate": {
+ *                   "field": {
+ *                     "fieldPath": "details.sensor",
+ *                     "comparator": "FIELD_COMPARATOR_EQ",
+ *                     "value": { "stringValue": "IR" }
+ *                   }
+ *                 }
+ *               }
+ *             ]
+ *           }
+ *         },
+ *         {
+ *           "actionPredicate": {
+ *             "field": {
+ *               "fieldPath": "details.priority",
+ *               "comparator": "FIELD_COMPARATOR_GT",
+ *               "value": { "numberValue": 5 }
+ *             }
+ *           }
+ *         }
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ * Matches: `(details.sensor == "EO" OR details.sensor == "IR") AND details.priority > 5`
+ *
+ * **Query in-progress actions by state name (enum-by-name in a field predicate):**
+ * ```
+ * {
+ *   "filter": {
+ *     "actionPredicate": {
+ *       "field": {
+ *         "fieldPath": "state",
+ *         "comparator": "FIELD_COMPARATOR_EQ",
+ *         "value": { "stringValue": "ACTION_STATE_IN_PROGRESS" }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.ActionQuery
+ */
+export type ActionQuery = Message<"raft.wdm.v1.service.ActionQuery"> & {
+    /**
+     * Filter by action states. If empty, all states are included.
+     * Multiple states use OR logic: returns actions in ANY of these states.
+     *
+     * @generated from field: repeated raft.wdm.v1.ActionState states = 1;
+     */
+    states: ActionState[];
+    /**
+     * Filter by assigned principal. If not set, all assignments are included.
+     * Multiple principals use OR logic: returns actions assigned to ANY of
+     * these principals.
+     *
+     * @generated from field: repeated raft.wdm.v1.Principal assigned_to = 2;
+     */
+    assignedTo: Principal[];
+    /**
+     * Filter by requesting principal. If not set, all requestors are included.
+     * Multiple principals use OR logic: returns actions requested by ANY of
+     * these principals.
+     *
+     * @generated from field: repeated raft.wdm.v1.Principal requested_by = 3;
+     */
+    requestedBy: Principal[];
+    /**
+     * Filter by authorizing principal. If not set, all authorizers are included.
+     * Multiple principals use OR logic: returns actions authorized by ANY of
+     * these principals.
+     *
+     * @generated from field: repeated raft.wdm.v1.Principal authorized_by = 4;
+     */
+    authorizedBy: Principal[];
+    /**
+     * Filter by action type. If empty, all types are included.
+     * Multiple types use OR logic: returns actions of ANY of these types.
+     * Examples: "isr_collection", "fire_mission", "movement", "resupply",
+     * "contact", "sitrep".
+     *
+     * @generated from field: repeated string type = 5;
+     */
+    type: string[];
+    /**
+     * Filter by priority. If empty, all priorities are included.
+     * Multiple priorities use OR logic: returns actions with ANY of these
+     * priorities.
+     *
+     * @generated from field: repeated raft.wdm.v1.ActionPriority priorities = 6;
+     */
+    priorities: ActionPriority[];
+    /**
+     * Filter by provenance (source, update time).
+     * Returns actions matching these provenance criteria.
+     *
+     * @generated from field: raft.wdm.v1.service.ProvenanceCondition provenance = 7;
+     */
+    provenance?: ProvenanceCondition | undefined;
+    /**
+     * Advanced filter using the Statement expression tree for full AND/OR/NOT
+     * composition over action fields. Leaf nodes must use action_predicate.
+     * If not set, no additional filtering is applied.
+     *
+     * object_predicate leaves in the tree are ignored (fail-open).
+     *
+     * Example: filter actions where details.sensor_type == "EO":
+     *   filter: {
+     *     action_predicate: {
+     *       field: {
+     *         field_path: "details.sensor_type",
+     *         comparator: FIELD_COMPARATOR_EQ,
+     *         value: { string_value: "EO" }
+     *       }
+     *     }
+     *   }
+     *
+     * Note that filter queries may be slow and are aggressively timed out.
+     *
+     * @generated from field: raft.wdm.v1.service.Statement filter = 8;
+     */
+    filter?: Statement | undefined;
+    /**
+     * Filter by action scope (TASK, ORDER, ALERT, REPORT, PHASE, SUB_TASK,
+     * DIRECTIVE, PLAN). Scope is an Action-specific concept that controls how
+     * consumers interpret the action. If empty, all scopes are included.
+     * Multiple scopes use OR logic: returns actions in ANY of these scopes.
+     *
+     * Common combinations:
+     *   - scopes=[5] : only individual tasks
+     *   - scopes=[7, 8] : only alerts and reports
+     *   - scopes=[2, 3, 4] : planning hierarchy (orders, plans, phases)
+     *
+     * @generated from field: repeated raft.wdm.v1.ActionScope scopes = 9;
+     */
+    scopes: ActionScope[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.ActionQuery.
+ * Use `create(ActionQuerySchema)` to create a new message.
+ */
+export declare const ActionQuerySchema: GenMessage<ActionQuery>;
+/**
+ * Query criteria for retrieving objects from storage.
+ *
+ * Uses a flat structure where all criteria are combined with AND logic between
+ * fields, and OR logic within repeated fields. Optimized for efficient bulk
+ * retrieval. Empty query returns all objects.
+ *
+ * For complex filtering (geographic bounding boxes, labels, nested boolean
+ * logic), stream objects and use ObjectStreamFilter instead.
+ *
+ * Logic semantics:
+ *   - Multiple values within a repeated field use OR (e.g., statuses=[1,2] means
+ *     status=ACTIVE OR status=INACTIVE)
+ *   - Different fields are combined with AND (e.g., statuses=[1] AND
+ *     affiliations=[7])
+ *
+ * Note: affiliation and environment filters traverse into the object's
+ * `assessment` submessage server-side. An affiliation filter matches
+ * `assessment.affiliation` and an environment filter matches
+ * `assessment.environment`. Objects missing an `assessment` are treated as
+ * having the UNSPECIFIED enum value for both.
+ *
+ * Examples:
+ *
+ * **Query hostile objects:**
+ * ```
+ * {
+ *   "affiliations": [7]
+ * }
+ * ```
+ * Matches: `assessment.affiliation=HOSTILE`
+ *
+ * **Query surface entities positively identified as friendly:**
+ * ```
+ * {
+ *   "environments": [5],
+ *   "affiliations": [4]
+ * }
+ * ```
+ * Matches: `assessment.environment=SURFACE AND assessment.affiliation=FRIEND`
+ *
+ * **Query non-simulated surface objects:**
+ * ```
+ * {
+ *   "environments": [5],
+ *   "flags": { "is_simulated": false }
+ * }
+ * ```
+ *
+ * **Query objects from specific sources:**
+ * ```
+ * {
+ *   "provenance": {
+ *     "source_names": ["USS Roosevelt CIC", "SIGINT Station Alpha"]
+ *   }
+ * }
+ * ```
+ *
+ * **Query objects updated recently:**
+ * ```
+ * {
+ *   "provenance": {
+ *     "updated_at": {
+ *       "start": "2025-12-18T10:00:00Z"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.ObjectQuery
+ */
+export type ObjectQuery = Message<"raft.wdm.v1.service.ObjectQuery"> & {
+    /**
+     * Filter by specific object IDs.
+     * Multiple IDs use OR logic: returns objects matching ANY of these IDs.
+     *
+     * @generated from field: repeated string object_ids = 1;
+     */
+    objectIds: string[];
+    /**
+     * Filter by object lifecycle status (ACTIVE, INACTIVE, DELETED).
+     * Multiple statuses use OR logic: returns objects with ANY of these statuses.
+     *
+     * @generated from field: repeated raft.wdm.v1.ObjectStatus statuses = 2;
+     */
+    statuses: ObjectStatus[];
+    /**
+     * Filter by affiliation (FRIEND, HOSTILE, NEUTRAL, etc.). Traverses
+     * assessment.affiliation server-side.
+     * Multiple affiliations use OR logic: returns objects with ANY of these
+     * affiliations.
+     *
+     * @generated from field: repeated raft.wdm.v1.Affiliation affiliations = 3;
+     */
+    affiliations: Affiliation[];
+    /**
+     * Filter by operating environment (SURFACE, AIR, SUBSURFACE, etc.).
+     * Traverses assessment.environment server-side.
+     * Multiple environments use OR logic: returns objects in ANY of these
+     * environments.
+     *
+     * @generated from field: repeated raft.wdm.v1.Environment environments = 4;
+     */
+    environments: Environment[];
+    /**
+     * Filter by operational flags (simulation, exercise, actionability).
+     * Returns objects matching these operational flags.
+     *
+     * @generated from field: raft.wdm.v1.service.ObjectFlagsCondition flags = 5;
+     */
+    flags?: ObjectFlagsCondition | undefined;
+    /**
+     * Filter by provenance (source, update time, source node).
+     * Returns objects matching these provenance criteria.
+     *
+     * @generated from field: raft.wdm.v1.service.ProvenanceCondition provenance = 6;
+     */
+    provenance?: ProvenanceCondition | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.ObjectQuery.
+ * Use `create(ObjectQuerySchema)` to create a new message.
+ */
+export declare const ObjectQuerySchema: GenMessage<ObjectQuery>;
+/**
+ * Filter criteria for streaming objects with real-time updates.
+ *
+ * Uses a statement-based composition pattern that allows for constructing
+ * complex boolean logic for precise filtering of streaming data.
+ * Empty filter returns all objects.
+ *
+ * For querying stored objects, use ObjectQuery instead.
+ *
+ * Examples:
+ *
+ * **Simple filter - all hostile objects:**
+ * ```
+ * {
+ *   "statement": {
+ *     "object_predicate": { "affiliations": { "values": [7] } }
+ *   }
+ * }
+ * ```
+ *
+ * **OR logic - friend or neutral:**
+ * ```
+ * {
+ *   "statement": {
+ *     "or": {
+ *       "statements": [
+ *         { "object_predicate": { "affiliations": { "values": [4] } } },
+ *         { "object_predicate": { "affiliations": { "values": [5] } } }
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **NOT logic - non-simulated objects:**
+ * ```
+ * {
+ *   "statement": {
+ *     "not": {
+ *       "statement": {
+ *         "object_predicate": { "flags": { "is_simulated": true } }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Complex nested - air or surface AND hostile AND NOT simulated:**
+ * ```
+ * {
+ *   "statement": {
+ *     "and": {
+ *       "statements": [
+ *         {
+ *           "or": {
+ *             "statements": [
+ *               { "object_predicate": { "environments": { "values": [4] } } },
+ *               { "object_predicate": { "environments": { "values": [5] } } }
+ *             ]
+ *           }
+ *         },
+ *         { "object_predicate": { "affiliations": { "values": [7] } } },
+ *         {
+ *           "not": {
+ *             "statement": {
+ *               "object_predicate": { "flags": { "is_simulated": true } }
+ *             }
+ *           }
+ *         }
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Geographic filter - objects in a specific area:**
+ * ```
+ * {
+ *   "statement": {
+ *     "object_predicate": {
+ *       "bounding_box": {
+ *         "value": {
+ *           "min_latitude": 33.0,
+ *           "min_longitude": 44.0,
+ *           "max_latitude": 34.0,
+ *           "max_longitude": 45.0
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Multi-environment - surface or subsurface objects:**
+ * ```
+ * {
+ *   "statement": {
+ *     "object_predicate": {
+ *       "environments": { "values": [5, 6] }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.ObjectStreamFilter
+ */
+export type ObjectStreamFilter = Message<"raft.wdm.v1.service.ObjectStreamFilter"> & {
+    /**
+     * Root statement of the filter expression tree.
+     * If not provided, returns all objects.
+     *
+     * @generated from field: raft.wdm.v1.service.Statement statement = 1;
+     */
+    statement?: Statement | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.ObjectStreamFilter.
+ * Use `create(ObjectStreamFilterSchema)` to create a new message.
+ */
+export declare const ObjectStreamFilterSchema: GenMessage<ObjectStreamFilter>;
+/**
+ * A Statement is the building block of the object filter. The outermost
+ * statement is the root of an expression tree which enables complete boolean
+ * logic. Statements are formed by grouping child statements or predicates
+ * according to the boolean operation to be applied.
+ *
+ * Examples:
+ *
+ * **Leaf predicate - match hostile affiliation:**
+ * ```
+ * Statement {
+ *   object_predicate: {
+ *     affiliations: { values: [7] }
+ *   }
+ * }
+ * ```
+ *
+ * **AND operation - surface objects that are hostile:**
+ * ```
+ * Statement {
+ *   and: {
+ *     statements: [
+ *       Statement { object_predicate: { environments: { values: [5] } } },
+ *       Statement { object_predicate: { affiliations: { values: [7] } } }
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * **OR operation - friend or neutral:**
+ * ```
+ * Statement {
+ *   or: {
+ *     statements: [
+ *       Statement { object_predicate: { affiliations: { values: [4] } } },
+ *       Statement { object_predicate: { affiliations: { values: [5] } } }
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * **NOT operation - exclude simulated:**
+ * ```
+ * Statement {
+ *   not: {
+ *     statement: Statement { object_predicate: { flags: { is_simulated: true } } }
+ *   }
+ * }
+ * ```
+ *
+ * **Nested composition - (air OR surface) AND (hostile OR suspect):**
+ * ```
+ * Statement {
+ *   and: {
+ *     statements: [
+ *       Statement {
+ *         or: {
+ *           statements: [
+ *             Statement { object_predicate: { environments: { values: [4] } } },
+ *             Statement { object_predicate: { environments: { values: [5] } } }
+ *           ]
+ *         }
+ *       },
+ *       Statement {
+ *         or: {
+ *           statements: [
+ *             Statement { object_predicate: { affiliations: { values: [7] } } },
+ *             Statement { object_predicate: { affiliations: { values: [6] } } }
+ *           ]
+ *         }
+ *       }
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.Statement
+ */
+export type Statement = Message<"raft.wdm.v1.service.Statement"> & {
+    /**
+     * @generated from oneof raft.wdm.v1.service.Statement.operation
+     */
+    operation: {
+        /**
+         * Boolean AND: all child statements must evaluate to true.
+         *
+         * @generated from field: raft.wdm.v1.service.AndOperation and = 1;
+         */
+        value: AndOperation;
+        case: "and";
+    } | {
+        /**
+         * Boolean OR: at least one child statement must evaluate to true.
+         *
+         * @generated from field: raft.wdm.v1.service.OrOperation or = 2;
+         */
+        value: OrOperation;
+        case: "or";
+    } | {
+        /**
+         * Boolean NOT: negates the child statement.
+         *
+         * @generated from field: raft.wdm.v1.service.NotOperation not = 3;
+         */
+        value: NotOperation;
+        case: "not";
+    } | {
+        /**
+         * Leaf predicate: evaluates a specific object field condition.
+         * Should not be mixed with action_predicate in the same tree;
+         * mismatched predicates are ignored (fail-open) by the evaluator.
+         *
+         * @generated from field: raft.wdm.v1.service.ObjectPredicate object_predicate = 4;
+         */
+        value: ObjectPredicate;
+        case: "objectPredicate";
+    } | {
+        /**
+         * Leaf predicate: evaluates a specific action field condition.
+         * Should not be mixed with object_predicate in the same tree;
+         * mismatched predicates are ignored (fail-open) by the evaluator.
+         *
+         * @generated from field: raft.wdm.v1.service.ActionPredicate action_predicate = 5;
+         */
+        value: ActionPredicate;
+        case: "actionPredicate";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message raft.wdm.v1.service.Statement.
+ * Use `create(StatementSchema)` to create a new message.
+ */
+export declare const StatementSchema: GenMessage<Statement>;
+/**
+ * AND operation applied to child statements.
+ *
+ * @generated from message raft.wdm.v1.service.AndOperation
+ */
+export type AndOperation = Message<"raft.wdm.v1.service.AndOperation"> & {
+    /**
+     * @generated from field: repeated raft.wdm.v1.service.Statement statements = 1;
+     */
+    statements: Statement[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.AndOperation.
+ * Use `create(AndOperationSchema)` to create a new message.
+ */
+export declare const AndOperationSchema: GenMessage<AndOperation>;
+/**
+ * OR operation applied to child statements.
+ *
+ * @generated from message raft.wdm.v1.service.OrOperation
+ */
+export type OrOperation = Message<"raft.wdm.v1.service.OrOperation"> & {
+    /**
+     * @generated from field: repeated raft.wdm.v1.service.Statement statements = 1;
+     */
+    statements: Statement[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.OrOperation.
+ * Use `create(OrOperationSchema)` to create a new message.
+ */
+export declare const OrOperationSchema: GenMessage<OrOperation>;
+/**
+ * NOT operation applied to a single child statement.
+ *
+ * @generated from message raft.wdm.v1.service.NotOperation
+ */
+export type NotOperation = Message<"raft.wdm.v1.service.NotOperation"> & {
+    /**
+     * @generated from field: raft.wdm.v1.service.Statement statement = 1;
+     */
+    statement?: Statement | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.NotOperation.
+ * Use `create(NotOperationSchema)` to create a new message.
+ */
+export declare const NotOperationSchema: GenMessage<NotOperation>;
+/**
+ * An ObjectPredicate is a leaf node in the filter expression tree that
+ * evaluates a specific condition against object fields. Each predicate tests
+ * one aspect of an object.
+ *
+ * Examples:
+ *
+ * **Status filter - match active objects:**
+ * ```
+ * ObjectPredicate { statuses: { values: [1] } }
+ * ```
+ *
+ * **Affiliation filter - match hostile objects:**
+ * ```
+ * ObjectPredicate { affiliations: { values: [7] } }
+ * ```
+ *
+ * **Multiple values - match friend OR neutral:**
+ * ```
+ * ObjectPredicate { affiliations: { values: [4, 5] } }
+ * ```
+ *
+ * **Bounding box - objects in Iraq (approx):**
+ * ```
+ * ObjectPredicate {
+ *   bounding_box: {
+ *     value: {
+ *       min_latitude: 29.0,
+ *       min_longitude: 39.0,
+ *       max_latitude: 37.0,
+ *       max_longitude: 49.0
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Label filter - maritime AIS objects:**
+ * ```
+ * ObjectPredicate {
+ *   labels: {
+ *     values: {
+ *       "domain": "maritime",
+ *       "source": "ais"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Operational flags - only real (non-simulated) objects:**
+ * ```
+ * ObjectPredicate { flags: { is_simulated: false } }
+ * ```
+ *
+ * **Operational flags - simulated exercise objects:**
+ * ```
+ * ObjectPredicate { flags: { is_simulated: true, is_exercise: true } }
+ * ```
+ *
+ * **Operational flags - actionable real-world objects:**
+ * ```
+ * ObjectPredicate { flags: { is_simulated: false, is_actionable: true } }
+ * ```
+ *
+ * **Provenance - objects from specific sources:**
+ * ```
+ * ObjectPredicate {
+ *   provenance: {
+ *     source_names: ["USS Roosevelt CIC", "SIGINT Station Alpha"]
+ *   }
+ * }
+ * ```
+ *
+ * **Provenance - objects updated in last hour:**
+ * ```
+ * ObjectPredicate {
+ *   provenance: {
+ *     updated_at: {
+ *       start: "2025-12-18T10:00:00Z",
+ *       end: "2025-12-18T11:00:00Z"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * **Provenance - specific source updated recently:**
+ * ```
+ * ObjectPredicate {
+ *   provenance: {
+ *     source_names: ["USS Roosevelt CIC"],
+ *     updated_at: {
+ *       start: "2025-12-18T10:00:00Z"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.ObjectPredicate
+ */
+export type ObjectPredicate = Message<"raft.wdm.v1.service.ObjectPredicate"> & {
+    /**
+     * @generated from oneof raft.wdm.v1.service.ObjectPredicate.condition
+     */
+    condition: {
+        /**
+         * Match objects with any of the specified IDs.
+         *
+         * @generated from field: raft.wdm.v1.service.ObjectIdCondition object_ids = 1;
+         */
+        value: ObjectIdCondition;
+        case: "objectIds";
+    } | {
+        /**
+         * Match objects with any of the specified statuses.
+         *
+         * @generated from field: raft.wdm.v1.service.StatusCondition statuses = 2;
+         */
+        value: StatusCondition;
+        case: "statuses";
+    } | {
+        /**
+         * Match objects with any of the specified affiliations.
+         * Traverses assessment.affiliation server-side.
+         *
+         * @generated from field: raft.wdm.v1.service.AffiliationCondition affiliations = 3;
+         */
+        value: AffiliationCondition;
+        case: "affiliations";
+    } | {
+        /**
+         * Match objects in any of the specified environments.
+         * Traverses assessment.environment server-side.
+         *
+         * @generated from field: raft.wdm.v1.service.EnvironmentCondition environments = 4;
+         */
+        value: EnvironmentCondition;
+        case: "environments";
+    } | {
+        /**
+         * Match objects within the specified geographic area.
+         *
+         * @generated from field: raft.wdm.v1.service.BoundingBoxCondition bounding_box = 5;
+         */
+        value: BoundingBoxCondition;
+        case: "boundingBox";
+    } | {
+        /**
+         * Match objects with all specified labels (key-value pairs).
+         *
+         * @generated from field: raft.wdm.v1.service.LabelCondition labels = 6;
+         */
+        value: LabelCondition;
+        case: "labels";
+    } | {
+        /**
+         * Match objects based on operational flags (simulation, exercise,
+         * actionability).
+         *
+         * @generated from field: raft.wdm.v1.service.ObjectFlagsCondition flags = 7;
+         */
+        value: ObjectFlagsCondition;
+        case: "flags";
+    } | {
+        /**
+         * Match objects based on provenance (source, update time, source node).
+         *
+         * @generated from field: raft.wdm.v1.service.ProvenanceCondition provenance = 8;
+         */
+        value: ProvenanceCondition;
+        case: "provenance";
+    } | {
+        /**
+         * Generic field-level condition using dot-notation paths and comparison
+         * operators. Enables filtering on any object field without requiring a
+         * purpose-built condition type.
+         *
+         * Uses protobuf field names (snake_case) resolved relative to Object.
+         * Supports traversal through nested messages and oneof fields.
+         *
+         * Examples:
+         *
+         * **Speed filter - objects faster than 15 m/s on a single axis:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "motion.velocity_enu_mps.x",
+         *     comparator: FIELD_COMPARATOR_GT,
+         *     value: { number_value: 15.0 }
+         *   }
+         * }
+         * ```
+         *
+         * **Enum by name - hostile affiliation:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "assessment.affiliation",
+         *     comparator: FIELD_COMPARATOR_EQ,
+         *     value: { string_value: "AFFILIATION_HOSTILE" }
+         *   }
+         * }
+         * ```
+         *
+         * **EXISTS - object has assessment set:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "assessment",
+         *     comparator: FIELD_COMPARATOR_EXISTS
+         *   }
+         * }
+         * ```
+         *
+         * **Type discrimination - object is a maritime vessel:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "type_info.maritime",
+         *     comparator: FIELD_COMPARATOR_EXISTS
+         *   }
+         * }
+         * ```
+         *
+         * **Shape discrimination - object is a circle:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "shape.circle",
+         *     comparator: FIELD_COMPARATOR_EXISTS
+         *   }
+         * }
+         * ```
+         *
+         * **IN list - object is in surface or subsurface environment:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "assessment.environment",
+         *     comparator: FIELD_COMPARATOR_IN,
+         *     value: {
+         *       list_value: {
+         *         values: [
+         *           { string_value: "ENVIRONMENT_SURFACE" },
+         *           { string_value: "ENVIRONMENT_SUBSURFACE" }
+         *         ]
+         *       }
+         *     }
+         *   }
+         * }
+         * ```
+         *
+         * **Case-insensitive name match:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "name",
+         *     comparator: FIELD_COMPARATOR_IEQ,
+         *     value: { string_value: "uss roosevelt" }
+         *   }
+         * }
+         * ```
+         *
+         * **Case-insensitive enum IN list:**
+         * ```
+         * ObjectPredicate {
+         *   field: {
+         *     field_path: "assessment.affiliation",
+         *     comparator: FIELD_COMPARATOR_IEQ_IN,
+         *     value: {
+         *       list_value: {
+         *         values: [
+         *           { string_value: "affiliation_hostile" },
+         *           { string_value: "affiliation_suspect" }
+         *         ]
+         *       }
+         *     }
+         *   }
+         * }
+         * ```
+         *
+         * @generated from field: raft.wdm.v1.service.FieldCondition field = 9;
+         */
+        value: FieldCondition;
+        case: "field";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message raft.wdm.v1.service.ObjectPredicate.
+ * Use `create(ObjectPredicateSchema)` to create a new message.
+ */
+export declare const ObjectPredicateSchema: GenMessage<ObjectPredicate>;
+/**
+ * An ActionPredicate is a leaf node in the filter expression tree that
+ * evaluates a specific condition against action fields. Parallel to
+ * ObjectPredicate but scoped to action-specific concerns.
+ *
+ * Currently supports generic field-level filtering via the field condition.
+ * Additional action-specific conditions (e.g., state, priority, scope,
+ * assignment) may be added in future iterations as purpose-built shortcuts.
+ *
+ * Examples:
+ *
+ * **Filter by action type:**
+ * ```
+ * ActionPredicate {
+ *   field: {
+ *     field_path: "type",
+ *     comparator: FIELD_COMPARATOR_EQ,
+ *     value: { string_value: "isr_collection" }
+ *   }
+ * }
+ * ```
+ *
+ * **Filter by scope:**
+ * ```
+ * ActionPredicate {
+ *   field: {
+ *     field_path: "scope",
+ *     comparator: FIELD_COMPARATOR_EQ,
+ *     value: { string_value: "ACTION_SCOPE_ALERT" }
+ *   }
+ * }
+ * ```
+ *
+ * **Filter by details field - sensor_type equals "EO":**
+ * ```
+ * ActionPredicate {
+ *   field: {
+ *     field_path: "details.sensor_type",
+ *     comparator: FIELD_COMPARATOR_EQ,
+ *     value: { string_value: "EO" }
+ *   }
+ * }
+ * ```
+ *
+ * **Check if BDA has been attached:**
+ * ```
+ * ActionPredicate {
+ *   field: {
+ *     field_path: "bda",
+ *     comparator: FIELD_COMPARATOR_EXISTS
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.ActionPredicate
+ */
+export type ActionPredicate = Message<"raft.wdm.v1.service.ActionPredicate"> & {
+    /**
+     * @generated from oneof raft.wdm.v1.service.ActionPredicate.condition
+     */
+    condition: {
+        /**
+         * Generic field-level condition using dot-notation paths and comparison
+         * operators. Enables filtering on any Action field without requiring a
+         * purpose-built condition type.
+         *
+         * Uses protobuf field names (snake_case), resolved relative to Action.
+         * Supports traversal through nested messages, oneof fields, and
+         * google.protobuf.Struct fields (e.g., "details.sensor_type").
+         *
+         * @generated from field: raft.wdm.v1.service.FieldCondition field = 1;
+         */
+        value: FieldCondition;
+        case: "field";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message raft.wdm.v1.service.ActionPredicate.
+ * Use `create(ActionPredicateSchema)` to create a new message.
+ */
+export declare const ActionPredicateSchema: GenMessage<ActionPredicate>;
+/**
+ * Condition for matching object IDs.
+ *
+ * @generated from message raft.wdm.v1.service.ObjectIdCondition
+ */
+export type ObjectIdCondition = Message<"raft.wdm.v1.service.ObjectIdCondition"> & {
+    /**
+     * Object must match one of these IDs.
+     *
+     * @generated from field: repeated string values = 1;
+     */
+    values: string[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.ObjectIdCondition.
+ * Use `create(ObjectIdConditionSchema)` to create a new message.
+ */
+export declare const ObjectIdConditionSchema: GenMessage<ObjectIdCondition>;
+/**
+ * Condition for matching object statuses.
+ *
+ * @generated from message raft.wdm.v1.service.StatusCondition
+ */
+export type StatusCondition = Message<"raft.wdm.v1.service.StatusCondition"> & {
+    /**
+     * Object must match one of these statuses.
+     *
+     * @generated from field: repeated raft.wdm.v1.ObjectStatus values = 1;
+     */
+    values: ObjectStatus[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.StatusCondition.
+ * Use `create(StatusConditionSchema)` to create a new message.
+ */
+export declare const StatusConditionSchema: GenMessage<StatusCondition>;
+/**
+ * Condition for matching object affiliations.
+ * Evaluated against assessment.affiliation server-side.
+ *
+ * @generated from message raft.wdm.v1.service.AffiliationCondition
+ */
+export type AffiliationCondition = Message<"raft.wdm.v1.service.AffiliationCondition"> & {
+    /**
+     * Object must match one of these affiliations.
+     *
+     * @generated from field: repeated raft.wdm.v1.Affiliation values = 1;
+     */
+    values: Affiliation[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.AffiliationCondition.
+ * Use `create(AffiliationConditionSchema)` to create a new message.
+ */
+export declare const AffiliationConditionSchema: GenMessage<AffiliationCondition>;
+/**
+ * Condition for matching object operating environments.
+ * Evaluated against assessment.environment server-side.
+ *
+ * @generated from message raft.wdm.v1.service.EnvironmentCondition
+ */
+export type EnvironmentCondition = Message<"raft.wdm.v1.service.EnvironmentCondition"> & {
+    /**
+     * Object must match one of these environments.
+     *
+     * @generated from field: repeated raft.wdm.v1.Environment values = 1;
+     */
+    values: Environment[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.EnvironmentCondition.
+ * Use `create(EnvironmentConditionSchema)` to create a new message.
+ */
+export declare const EnvironmentConditionSchema: GenMessage<EnvironmentCondition>;
+/**
+ * Condition for matching objects within a geographic bounding box.
+ *
+ * @generated from message raft.wdm.v1.service.BoundingBoxCondition
+ */
+export type BoundingBoxCondition = Message<"raft.wdm.v1.service.BoundingBoxCondition"> & {
+    /**
+     * @generated from field: raft.wdm.v1.service.GeographicBoundingBox value = 1;
+     */
+    value?: GeographicBoundingBox | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.BoundingBoxCondition.
+ * Use `create(BoundingBoxConditionSchema)` to create a new message.
+ */
+export declare const BoundingBoxConditionSchema: GenMessage<BoundingBoxCondition>;
+/**
+ * Condition for matching object labels.
+ *
+ * @generated from message raft.wdm.v1.service.LabelCondition
+ */
+export type LabelCondition = Message<"raft.wdm.v1.service.LabelCondition"> & {
+    /**
+     * Object must have ALL of these labels (AND logic within the map).
+     *
+     * @generated from field: map<string, string> values = 1;
+     */
+    values: {
+        [key: string]: string;
+    };
+};
+/**
+ * Describes the message raft.wdm.v1.service.LabelCondition.
+ * Use `create(LabelConditionSchema)` to create a new message.
+ */
+export declare const LabelConditionSchema: GenMessage<LabelCondition>;
+/**
+ * Condition for matching object operational flags.
+ * Use optional fields to match on specific flags. If a field is not set,
+ * that flag is not considered in the match.
+ *
+ * Examples:
+ * - Match only simulated: `{ is_simulated: true }`
+ * - Match only non-simulated: `{ is_simulated: false }`
+ * - Match only exercise: `{ is_exercise: true }`
+ * - Match simulated AND exercise: `{ is_simulated: true, is_exercise: true }`
+ * - Match actionable live objects: `{ is_simulated: false, is_actionable: true }`
+ *
+ * @generated from message raft.wdm.v1.service.ObjectFlagsCondition
+ */
+export type ObjectFlagsCondition = Message<"raft.wdm.v1.service.ObjectFlagsCondition"> & {
+    /**
+     * If set, match objects where is_simulated equals this value.
+     *
+     * @generated from field: optional bool is_simulated = 1;
+     */
+    isSimulated?: boolean | undefined;
+    /**
+     * If set, match objects where is_exercise equals this value.
+     *
+     * @generated from field: optional bool is_exercise = 2;
+     */
+    isExercise?: boolean | undefined;
+    /**
+     * If set, match objects where is_actionable equals this value.
+     * Actionable means the object can receive warfighting actions.
+     *
+     * @generated from field: optional bool is_actionable = 3;
+     */
+    isActionable?: boolean | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.ObjectFlagsCondition.
+ * Use `create(ObjectFlagsConditionSchema)` to create a new message.
+ */
+export declare const ObjectFlagsConditionSchema: GenMessage<ObjectFlagsCondition>;
+/**
+ * Condition for matching provenance (data lineage and source attribution).
+ * Use optional fields to match on specific provenance attributes. If a field
+ * is not set, that attribute is not considered in the match.
+ *
+ * Evaluates against ProvenanceRecord fields (`name`, `updated_at`,
+ * `source_node_id`) on the target object or action.
+ *
+ * Examples:
+ * - Match by source: `{ source_names: ["Alpha 1"] }`
+ * - Match by time: `{ updated_at: { start: "...", end: "..." } }`
+ * - Match both: `{ source_names: ["Alpha 1"], updated_at: {...} }`
+ * - Match by source node: `{ source_node_ids: ["24160ed6-e512-4972-b54a-cb8f81f9e196"] }`
+ *
+ * @generated from message raft.wdm.v1.service.ProvenanceCondition
+ */
+export type ProvenanceCondition = Message<"raft.wdm.v1.service.ProvenanceCondition"> & {
+    /**
+     * If set, match records where provenance.name matches one of these values.
+     *
+     * @generated from field: repeated string source_names = 1;
+     */
+    sourceNames: string[];
+    /**
+     * If set, match records where provenance.updated_at falls within this range.
+     *
+     * @generated from field: raft.wdm.v1.service.TimeRange updated_at = 2;
+     */
+    updatedAt?: TimeRange | undefined;
+    /**
+     * If set, match records where provenance.source_node_id matches one of
+     * these values.
+     *
+     * @generated from field: repeated string source_node_ids = 3;
+     */
+    sourceNodeIds: string[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.ProvenanceCondition.
+ * Use `create(ProvenanceConditionSchema)` to create a new message.
+ */
+export declare const ProvenanceConditionSchema: GenMessage<ProvenanceCondition>;
+/**
+ * Geographic bounding box for spatial filtering.
+ * Defines a rectangular area using WGS-84 coordinates.
+ *
+ * @generated from message raft.wdm.v1.service.GeographicBoundingBox
+ */
+export type GeographicBoundingBox = Message<"raft.wdm.v1.service.GeographicBoundingBox"> & {
+    /**
+     * Southwest corner latitude in decimal degrees.
+     * Range: -90.0 to +90.0
+     *
+     * @generated from field: double min_latitude = 1;
+     */
+    minLatitude: number;
+    /**
+     * Southwest corner longitude in decimal degrees.
+     * Range: -180.0 to +180.0
+     *
+     * @generated from field: double min_longitude = 2;
+     */
+    minLongitude: number;
+    /**
+     * Northeast corner latitude in decimal degrees.
+     * Range: -90.0 to +90.0
+     *
+     * @generated from field: double max_latitude = 3;
+     */
+    maxLatitude: number;
+    /**
+     * Northeast corner longitude in decimal degrees.
+     * Range: -180.0 to +180.0
+     *
+     * @generated from field: double max_longitude = 4;
+     */
+    maxLongitude: number;
+};
+/**
+ * Describes the message raft.wdm.v1.service.GeographicBoundingBox.
+ * Use `create(GeographicBoundingBoxSchema)` to create a new message.
+ */
+export declare const GeographicBoundingBoxSchema: GenMessage<GeographicBoundingBox>;
+/**
+ * Time range for temporal filtering.
+ *
+ * @generated from message raft.wdm.v1.service.TimeRange
+ */
+export type TimeRange = Message<"raft.wdm.v1.service.TimeRange"> & {
+    /**
+     * Start of the time range (inclusive).
+     *
+     * @generated from field: google.protobuf.Timestamp start = 1;
+     */
+    start?: Timestamp | undefined;
+    /**
+     * End of the time range (inclusive).
+     * If not provided, defaults to current time.
+     *
+     * @generated from field: google.protobuf.Timestamp end = 2;
+     */
+    end?: Timestamp | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.TimeRange.
+ * Use `create(TimeRangeSchema)` to create a new message.
+ */
+export declare const TimeRangeSchema: GenMessage<TimeRange>;
+/**
+ * A typed value for use in field-level comparisons.
+ *
+ * Numeric proto types (int32, uint32, float, double) are all represented as
+ * number_value (double), which exactly represents all int32/uint32/float
+ * values and all practical int64 values up to 2^53.
+ *
+ * Enum fields accept both string_value (by enum value name, e.g.,
+ * "AFFILIATION_HOSTILE") and number_value (by enum number, e.g., 7).
+ *
+ * @generated from message raft.wdm.v1.service.FieldValue
+ */
+export type FieldValue = Message<"raft.wdm.v1.service.FieldValue"> & {
+    /**
+     * @generated from oneof raft.wdm.v1.service.FieldValue.value
+     */
+    value: {
+        /**
+         * Boolean value.
+         *
+         * @generated from field: bool bool_value = 1;
+         */
+        value: boolean;
+        case: "boolValue";
+    } | {
+        /**
+         * Numeric value. Covers all numeric proto kinds (int32, uint32, float,
+         * double, int64 up to 2^53).
+         *
+         * @generated from field: double number_value = 2;
+         */
+        value: number;
+        case: "numberValue";
+    } | {
+        /**
+         * String value. Also used for enum comparison by name.
+         *
+         * @generated from field: string string_value = 3;
+         */
+        value: string;
+        case: "stringValue";
+    } | {
+        /**
+         * Timestamp value. For temporal comparisons on timestamp fields.
+         *
+         * @generated from field: google.protobuf.Timestamp timestamp_value = 4;
+         */
+        value: Timestamp;
+        case: "timestampValue";
+    } | {
+        /**
+         * List of values. Used with FIELD_COMPARATOR_IN and FIELD_COMPARATOR_IEQ_IN.
+         *
+         * @generated from field: raft.wdm.v1.service.FieldValueList list_value = 5;
+         */
+        value: FieldValueList;
+        case: "listValue";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message raft.wdm.v1.service.FieldValue.
+ * Use `create(FieldValueSchema)` to create a new message.
+ */
+export declare const FieldValueSchema: GenMessage<FieldValue>;
+/**
+ * A list of typed values for use with the IN and IEQ_IN comparators.
+ *
+ * @generated from message raft.wdm.v1.service.FieldValueList
+ */
+export type FieldValueList = Message<"raft.wdm.v1.service.FieldValueList"> & {
+    /**
+     * Values to compare against. Target field must match any one of these.
+     *
+     * @generated from field: repeated raft.wdm.v1.service.FieldValue values = 1;
+     */
+    values: FieldValue[];
+};
+/**
+ * Describes the message raft.wdm.v1.service.FieldValueList.
+ * Use `create(FieldValueListSchema)` to create a new message.
+ */
+export declare const FieldValueListSchema: GenMessage<FieldValueList>;
+/**
+ * A generic condition that filters on any object or action field using
+ * dot-notation paths and comparison operators.
+ *
+ * Complements purpose-built conditions (statuses, affiliations, bounding box,
+ * etc.) which remain as ergonomic shortcuts. Use FieldCondition for fields not
+ * covered by existing condition types.
+ *
+ * Field paths use protobuf field names (snake_case), resolved relative to
+ * Object (within ObjectPredicate) or Action (within ActionPredicate). Supports
+ * traversal through nested messages and oneof fields (e.g.,
+ * "shape.circle.radius_meters", "type_info.maritime.mmsi").
+ *
+ * Behavior:
+ *   - Invalid field path: match all (fail-open), consistent with existing
+ *     unknown-predicate handling.
+ *   - Type mismatch (e.g., string_value for bool field): no match.
+ *   - Nil intermediate message: field treated as default/zero value per proto3
+ *     semantics. EXISTS returns false.
+ *   - Unspecified comparator: match all (fail-open for unset enum).
+ *   - Repeated/map fields in path: no match (out of scope for v1).
+ *
+ * Examples:
+ *
+ * **Objects faster than 15 m/s on the east axis:**
+ * ```json
+ * {
+ *   "field_path": "motion.velocity_enu_mps.x",
+ *   "comparator": "FIELD_COMPARATOR_GT",
+ *   "value": { "number_value": 15.0 }
+ * }
+ * ```
+ *
+ * **Object has assessment set:**
+ * ```json
+ * {
+ *   "field_path": "assessment",
+ *   "comparator": "FIELD_COMPARATOR_EXISTS"
+ * }
+ * ```
+ *
+ * **Circles with radius > 5km:**
+ * ```json
+ * {
+ *   "field_path": "shape.circle.radius_meters",
+ *   "comparator": "FIELD_COMPARATOR_GT",
+ *   "value": { "number_value": 5000 }
+ * }
+ * ```
+ *
+ * **Case-insensitive name match:**
+ * ```json
+ * {
+ *   "field_path": "name",
+ *   "comparator": "FIELD_COMPARATOR_IEQ",
+ *   "value": { "string_value": "uss roosevelt" }
+ * }
+ * ```
+ *
+ * **Case-insensitive affiliation IN list:**
+ * ```json
+ * {
+ *   "field_path": "assessment.affiliation",
+ *   "comparator": "FIELD_COMPARATOR_IEQ_IN",
+ *   "value": {
+ *     "list_value": {
+ *       "values": [
+ *         { "string_value": "affiliation_hostile" },
+ *         { "string_value": "affiliation_suspect" }
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @generated from message raft.wdm.v1.service.FieldCondition
+ */
+export type FieldCondition = Message<"raft.wdm.v1.service.FieldCondition"> & {
+    /**
+     * Dot-notation path to the field.
+     *
+     * Uses protobuf field names (snake_case), resolved relative to Object
+     * (within ObjectPredicate) or Action (within ActionPredicate). Supports
+     * nested paths through messages and oneof fields.
+     *
+     * Examples: "name", "assessment.affiliation",
+     * "location.position.latitude_degrees", "shape.circle.radius_meters",
+     * "type", "scope", "state".
+     *
+     * @generated from field: string field_path = 1;
+     */
+    fieldPath: string;
+    /**
+     * Comparison operator to apply.
+     *
+     * @generated from field: raft.wdm.v1.service.FieldComparator comparator = 2;
+     */
+    comparator: FieldComparator;
+    /**
+     * Value to compare against.
+     * Ignored when comparator is FIELD_COMPARATOR_EXISTS.
+     *
+     * @generated from field: raft.wdm.v1.service.FieldValue value = 3;
+     */
+    value?: FieldValue | undefined;
+};
+/**
+ * Describes the message raft.wdm.v1.service.FieldCondition.
+ * Use `create(FieldConditionSchema)` to create a new message.
+ */
+export declare const FieldConditionSchema: GenMessage<FieldCondition>;
+/**
+ * Comparison operators for generic field-level filtering.
+ *
+ * Not all comparators are valid for all field types. See the compatibility
+ * matrix in the FieldCondition documentation for details.
+ *
+ * | Comparator | bool | numeric | string | enum | timestamp | message |
+ * |------------|------|---------|--------|------|-----------|---------|
+ * | EQ         | x    | x       | x      | x    | x         |         |
+ * | NEQ        | x    | x       | x      | x    | x         |         |
+ * | LT         |      | x       | x      |      | x         |         |
+ * | LTE        |      | x       | x      |      | x         |         |
+ * | GT         |      | x       | x      |      | x         |         |
+ * | GTE        |      | x       | x      |      | x         |         |
+ * | IN         |      | x       | x      | x    |           |         |
+ * | EXISTS     | x    | x       | x      | x    | x         | x       |
+ * | IEQ        |      |         | x      | x    |           |         |
+ * | IEQ_IN     |      |         | x      | x    |           |         |
+ *
+ * @generated from enum raft.wdm.v1.service.FieldComparator
+ */
+export declare enum FieldComparator {
+    /**
+     * Unspecified comparator. Server treats this as match-all (fail-open).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Equal to (==).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_EQ = 1;
+     */
+    EQ = 1,
+    /**
+     * Not equal to (!=).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_NEQ = 2;
+     */
+    NEQ = 2,
+    /**
+     * Less than (<).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_LT = 3;
+     */
+    LT = 3,
+    /**
+     * Less than or equal to (<=).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_LTE = 4;
+     */
+    LTE = 4,
+    /**
+     * Greater than (>).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_GT = 5;
+     */
+    GT = 5,
+    /**
+     * Greater than or equal to (>=).
+     *
+     * @generated from enum value: FIELD_COMPARATOR_GTE = 6;
+     */
+    GTE = 6,
+    /**
+     * Value is one of a list. Requires FieldValue.list_value.
+     *
+     * @generated from enum value: FIELD_COMPARATOR_IN = 7;
+     */
+    IN = 7,
+    /**
+     * Field is set (non-default for scalars, non-nil for messages).
+     * The FieldCondition.value field is ignored when this comparator is used.
+     *
+     * @generated from enum value: FIELD_COMPARATOR_EXISTS = 8;
+     */
+    EXISTS = 8,
+    /**
+     * Case-insensitive equal to. String and enum fields only.
+     * For enums, compares against the enum value name.
+     *
+     * @generated from enum value: FIELD_COMPARATOR_IEQ = 9;
+     */
+    IEQ = 9,
+    /**
+     * Case-insensitive IN. String and enum fields only.
+     * Requires FieldValue.list_value. For enums, compares against enum value
+     * names.
+     *
+     * @generated from enum value: FIELD_COMPARATOR_IEQ_IN = 10;
+     */
+    IEQ_IN = 10
+}
+/**
+ * Describes the enum raft.wdm.v1.service.FieldComparator.
+ */
+export declare const FieldComparatorSchema: GenEnum<FieldComparator>;
+//# sourceMappingURL=query_pb.d.ts.map