@laserdata/laser-sdk 0.4.0 → 0.5.0

package/dist/wire/filter.d.ts

@@ -0,0 +1,772 @@
+import { type Grant } from "./authz.js";
+import type { CmpOp, Predicate } from "./query.js";
+import { type ResultCode } from "./result.js";
+import { type TypedValue } from "./schema.js";
+export declare const FILTER_EVALUATOR_VERSION = 1;
+export declare const MAX_REGEX_PREDICATES = 4;
+/** One step of a {@link FieldPath}: an object key or an array index. */
+export type PathSegment = {
+    readonly kind: "key";
+    readonly key: string;
+} | {
+    readonly kind: "index";
+    readonly index: number;
+};
+/**
+ * A validated location inside a decoded payload. Keys are separated by `.`,
+ * array elements are selected with `[n]`, and a literal `.`, `[`, `]`, or `\`
+ * inside a key is escaped with `\`. The text form is canonical.
+ */
+export declare class FieldPath {
+    readonly segments: readonly PathSegment[];
+    private constructor();
+    static parse(text: string): FieldPath;
+    toString(): string;
+}
+/** How a timestamp is written in the payload or literal. */
+export type TimestampFormat = "rfc3339" | "epoch_seconds" | "epoch_millis" | "epoch_micros";
+/** An explicit value coercion. A value that does not parse under it is unknown. */
+export type Coerce = {
+    readonly kind: "timestamp";
+    readonly format: TimestampFormat;
+} | {
+    readonly kind: "number";
+};
+export interface CoercedPredicate {
+    readonly pred: Predicate;
+    readonly coerce: Coerce;
+}
+export interface HeaderPredicate {
+    readonly key: string;
+    readonly op: CmpOp;
+    readonly value: TypedValue;
+}
+/**
+ * How the payload is decoded before payload predicates run. `unknown` is a
+ * codec this build does not know, for example one a newer catalog saved: it
+ * decodes so listings stay readable, but it never validates or compiles.
+ */
+export type FilterCodec = "json" | "cbor" | "avro" | "protobuf" | "headers_only" | "unknown";
+/** What happens to a record whose payload cannot be decoded. */
+export type FaultPolicy = "stop" | "pass" | "drop";
+/**
+ * What happens to a record the filter cannot judge on its own terms: one in
+ * another format (`foreignPolicy`), or one where a predicate's value has a
+ * type it cannot compare (`mismatchPolicy`). `reject` skips the record,
+ * `pass` delivers it marked unevaluated so the consumer decides.
+ */
+export type RecordPolicy = "reject" | "pass";
+/** How a text predicate matches, from cheapest to most expensive. */
+export type TextMatch = "equals" | "prefix" | "suffix" | "contains" | "glob" | "regex";
+/**
+ * A text match on a payload field, or on a header for `header_text`. The value
+ * must be text: a missing value is unknown, another type is a type mismatch.
+ */
+export interface TextPredicate {
+    readonly field: string;
+    readonly kind: TextMatch;
+    readonly pattern: string;
+    readonly caseInsensitive?: boolean;
+}
+/**
+ * A declarative predicate over one record. Comparison truth is three-valued: a
+ * missing field or a type mismatch is unknown, and an unknown root selects
+ * nothing.
+ */
+export type FilterExpr = {
+    readonly kind: "all";
+    readonly children: readonly FilterExpr[];
+} | {
+    readonly kind: "any";
+    readonly children: readonly FilterExpr[];
+} | {
+    readonly kind: "not";
+    readonly child: FilterExpr;
+} | {
+    readonly kind: "pred";
+    readonly predicate: Predicate;
+} | {
+    readonly kind: "pred_as";
+    readonly predicate: CoercedPredicate;
+} | {
+    readonly kind: "present";
+    readonly path: FieldPath;
+} | {
+    readonly kind: "absent";
+    readonly path: FieldPath;
+} | {
+    readonly kind: "header";
+    readonly predicate: HeaderPredicate;
+} | {
+    readonly kind: "text";
+    readonly predicate: TextPredicate;
+} | {
+    readonly kind: "header_text";
+    readonly predicate: TextPredicate;
+};
+/**
+ * A literal in the builders. An integral `number` or a `bigint` is a `long`, a
+ * fractional `number` a `double`. Pass a {@link TypedValue} for another kind.
+ */
+export type FilterLiteral = string | number | bigint | boolean | null | TypedValue | readonly FilterLiteral[];
+/** Builders for the `FilterExpr` type. */
+export declare const FilterExpr: {
+    readonly all: (children: readonly FilterExpr[]) => FilterExpr;
+    readonly any: (children: readonly FilterExpr[]) => FilterExpr;
+    readonly negate: (child: FilterExpr) => FilterExpr;
+    readonly pred: (fieldName: string, op: CmpOp, value: FilterLiteral) => FilterExpr;
+    readonly predAs: (fieldName: string, op: CmpOp, value: FilterLiteral, coerce: Coerce) => FilterExpr;
+    readonly present: (path: string) => FilterExpr;
+    readonly absent: (path: string) => FilterExpr;
+    readonly header: (key: string, op: CmpOp, value: FilterLiteral) => FilterExpr;
+    readonly text: (fieldName: string, kind: TextMatch, pattern: string, caseInsensitive?: boolean) => FilterExpr;
+    readonly headerText: (key: string, kind: TextMatch, pattern: string, caseInsensitive?: boolean) => FilterExpr;
+};
+/** One consumer filter: the expression plus everything that changes what it selects. */
+export interface ConsumerFilter {
+    readonly v: number;
+    readonly evaluatorVersion: number;
+    readonly expr: FilterExpr;
+    readonly codec: FilterCodec;
+    readonly faultPolicy: FaultPolicy;
+    /** Default `reject`. */
+    readonly foreignPolicy?: RecordPolicy;
+    /** Default `reject`. */
+    readonly mismatchPolicy?: RecordPolicy;
+    readonly schemaRefs: readonly number[];
+}
+/** Builders for the `ConsumerFilter` type. */
+export declare const ConsumerFilter: {
+    /** Decode the payload as JSON, with the default `stop` fault policy. */
+    readonly json: (expr: FilterExpr, faultPolicy?: FaultPolicy) => ConsumerFilter;
+    readonly cbor: (expr: FilterExpr, faultPolicy?: FaultPolicy) => ConsumerFilter;
+    readonly avro: (expr: FilterExpr, schemaRefs: readonly number[], faultPolicy?: FaultPolicy) => ConsumerFilter;
+    readonly protobuf: (expr: FilterExpr, schemaRefs: readonly number[], faultPolicy?: FaultPolicy) => ConsumerFilter;
+    /** Never decode the payload. Only header predicates are allowed. */
+    readonly headersOnly: (expr: FilterExpr, faultPolicy?: FaultPolicy) => ConsumerFilter;
+    /** The same filter under another policy for records that do not decode. */
+    readonly withFaultPolicy: (filter: ConsumerFilter, faultPolicy: FaultPolicy) => ConsumerFilter;
+    /** The same filter under another policy for records of another codec. */
+    readonly withForeignPolicy: (filter: ConsumerFilter, foreignPolicy: RecordPolicy) => ConsumerFilter;
+    /** The same filter under another policy for a field of an unexpected type. */
+    readonly withMismatchPolicy: (filter: ConsumerFilter, mismatchPolicy: RecordPolicy) => ConsumerFilter;
+};
+export declare function filterExprReadsPayload(expr: FilterExpr): boolean;
+export declare function filterExprReadsHeaders(expr: FilterExpr): boolean;
+/**
+ * SHA-256 over a domain tag and the canonical JSON encoding of the filter, byte
+ * for byte what every server and SDK computes.
+ */
+export declare function consumerFilterDigest(filter: ConsumerFilter): Uint8Array;
+/** The canonical JSON text of a filter, the encoding its digest covers. */
+export declare function consumerFilterJson(filter: ConsumerFilter): string;
+/** Parse a filter from its canonical JSON text. */
+export declare function decodeConsumerFilterJson(text: string): ConsumerFilter;
+export declare function validateConsumerFilter(filter: ConsumerFilter): void;
+/** One glob element after escapes are resolved: any run, any one, or a literal. */
+export type GlobToken = {
+    readonly kind: "run";
+} | {
+    readonly kind: "one";
+} | {
+    readonly kind: "literal";
+    readonly value: string;
+};
+export declare function globTokens(pattern: string): GlobToken[] | undefined;
+export declare function unportableRegexConstruct(pattern: string): string | undefined;
+/**
+ * An exact decimal number, compared without floating-point rounding. Leading
+ * and trailing zeros are normalized away, so `1.50` equals `1.5` and `-0`
+ * equals `0`.
+ */
+export declare class ExactDecimal {
+    private readonly negative;
+    private readonly integer;
+    private readonly fraction;
+    private constructor();
+    /** Parse `[+-]digits[.digits]`: no exponent, no whitespace, at most 512 digits. */
+    static parse(text: string): ExactDecimal | undefined;
+    static fromInteger(value: bigint): ExactDecimal;
+    /** The exact value of a finite double, `undefined` for infinities and NaN. */
+    static fromDouble(value: number): ExactDecimal | undefined;
+    private static normalized;
+    /** `-1`, `0`, or `1` as this value is below, equal to, or above `other`. */
+    compare(other: ExactDecimal): number;
+    private static magnitude;
+    toString(): string;
+}
+/** Microseconds since the epoch for a text value, `undefined` when it does not parse exactly. */
+export declare function timestampFromText(format: TimestampFormat, text: string): bigint | undefined;
+/** Microseconds since the epoch for an integer value, `undefined` on overflow or for RFC 3339. */
+export declare function timestampFromInteger(format: TimestampFormat, value: bigint): bigint | undefined;
+/** The stream and topic a filtered read or preview addresses, by name. */
+export interface FilterSource {
+    readonly stream: string;
+    readonly topic: string;
+}
+/** Whose progress a filtered read follows. */
+export type FilterConsumer = {
+    readonly kind: "group_id";
+    readonly id: bigint;
+} | {
+    readonly kind: "consumer";
+    readonly name: string;
+} | {
+    readonly kind: "group";
+    readonly name: string;
+};
+/** Which filter a read executes. */
+export type FilterRef = {
+    readonly kind: "inline";
+    readonly filter: ConsumerFilter;
+} | {
+    readonly kind: "revision";
+    readonly filterId: number;
+    readonly revision: number;
+} | {
+    readonly kind: "bound";
+};
+/** Which replica serves the read. */
+export type ReadMode = "primary" | "local";
+/** The exact source history a page was read from. */
+export interface SourceGeneration {
+    readonly streamId: number;
+    readonly streamCreatedAtMicros: bigint;
+    readonly topicId: number;
+    readonly topicCreatedAtMicros: bigint;
+    readonly partitionId: number;
+    readonly partitionCreatedRevision: bigint;
+    readonly purgeGeneration: bigint;
+}
+export interface Continuation {
+    readonly groupId?: bigint;
+    readonly nextScanOffset: bigint;
+    readonly generation: SourceGeneration;
+    readonly digest: Uint8Array;
+    /**
+     * The route the page was read on. A continuation from a local page never
+     * resumes a primary read, because a local replica can lag a purge.
+     */
+    readonly readMode: ReadMode;
+}
+/** Where a filtered read starts. */
+export type FilteredStart = {
+    readonly kind: "next";
+} | {
+    readonly kind: "first";
+} | {
+    readonly kind: "last";
+} | {
+    readonly kind: "offset";
+    readonly offset: bigint;
+} | {
+    readonly kind: "timestamp";
+    readonly micros: bigint;
+} | {
+    readonly kind: "continue";
+    readonly continuation: Continuation;
+};
+export interface FilteredPollRequest {
+    readonly v: number;
+    readonly source: FilterSource;
+    readonly partitionId: number;
+    readonly consumer: FilterConsumer;
+    readonly filter: FilterRef;
+    readonly start: FilteredStart;
+    readonly count: number;
+    readonly maxReplyBytes: number;
+    readonly readMode: ReadMode;
+}
+export type StopReason = "filled" | "budget" | "end_of_visible" | "fault" | "oversized_record";
+export type FaultReason = "malformed" | "too_large" | "too_deep" | "missing_schema" | "schema_not_allowed" | "schema_mismatch" | "foreign_codec" | "type_mismatch";
+export interface RecordFault {
+    readonly offset: bigint;
+    readonly reason: FaultReason;
+}
+export interface AppliedPolicy {
+    readonly groupId?: bigint;
+    readonly digest: Uint8Array;
+    readonly filterId?: number;
+    readonly revision?: number;
+}
+/** One page of a filtered read. `records` is a standard polled-messages body. */
+export interface FilteredPage {
+    readonly v: number;
+    readonly partitionId: number;
+    readonly policy: AppliedPolicy;
+    readonly generation: SourceGeneration;
+    readonly readMode: ReadMode;
+    readonly nextScanOffset?: bigint;
+    readonly safeAckOffset?: bigint;
+    readonly frontier: bigint;
+    readonly examined: number;
+    readonly matched: number;
+    readonly stop: StopReason;
+    readonly fault?: RecordFault;
+    readonly evaluationLimits?: {
+        readonly maxPayloadBytes: number;
+        readonly maxDepth: number;
+    };
+    readonly unevaluated: readonly bigint[];
+    readonly records: Uint8Array;
+}
+/** The start of the next request: continue after `page`, or repeat `original`. */
+export declare function nextFilteredStart(page: FilteredPage, original: FilteredStart): FilteredStart;
+export interface FilteredAck {
+    readonly groupId?: bigint;
+    readonly v: number;
+    readonly source: FilterSource;
+    readonly partitionId: number;
+    readonly consumer: FilterConsumer;
+    readonly generation: SourceGeneration;
+    readonly digest: Uint8Array;
+    readonly offset: bigint;
+}
+export interface AckReceipt {
+    readonly partitionId: number;
+    readonly offset: bigint;
+    readonly generation: SourceGeneration;
+}
+export interface FilterPreviewRequest {
+    readonly v: number;
+    readonly source: FilterSource;
+    readonly partitionId: number;
+    readonly filter: FilterRef;
+    readonly fromOffset: bigint;
+    readonly maxExamined: number;
+    readonly maxRecords: number;
+    readonly explain: boolean;
+}
+export type Verdict = "selected" | "rejected" | "fault";
+export type Truth = "match" | "no_match" | "unknown";
+export interface ExplainNode {
+    readonly label: string;
+    readonly truth?: Truth;
+    readonly children: readonly ExplainNode[];
+}
+export interface FilterExplanation {
+    readonly verdict: Verdict;
+    readonly fault?: FaultReason;
+    readonly root: ExplainNode;
+}
+export interface PreviewRecord {
+    readonly offset: bigint;
+    readonly timestampMicros: bigint;
+    readonly verdict: Verdict;
+    readonly fault?: FaultReason;
+    readonly payloadText: string;
+    readonly payloadTruncated: boolean;
+    readonly explanation?: FilterExplanation;
+}
+export interface FilterPreview {
+    readonly v: number;
+    readonly partitionId: number;
+    readonly policy: AppliedPolicy;
+    readonly readMode: ReadMode;
+    readonly examined: number;
+    readonly matched: number;
+    readonly faults: number;
+    readonly stop: StopReason;
+    readonly nextOffset?: bigint;
+    readonly frontier: bigint;
+    readonly records: readonly PreviewRecord[];
+}
+/** A typed user header value as the evaluator reads it. */
+export type HeaderScalar = {
+    readonly kind: "bool";
+    readonly value: boolean;
+} | {
+    readonly kind: "int";
+    readonly value: bigint;
+} | {
+    readonly kind: "uint";
+    readonly value: bigint;
+} | {
+    readonly kind: "float";
+    readonly value: number;
+} | {
+    readonly kind: "string";
+    readonly value: string;
+} | {
+    readonly kind: "raw";
+    readonly value: Uint8Array;
+};
+export interface FilterHeader {
+    readonly key: string;
+    readonly value: HeaderScalar;
+}
+export interface FilterTestRequest {
+    readonly v: number;
+    readonly filter: FilterRef;
+    readonly payload: Uint8Array;
+    readonly headers: readonly FilterHeader[];
+}
+export interface FilterTestResult {
+    readonly v: number;
+    readonly policy: AppliedPolicy;
+    readonly explanation: FilterExplanation;
+}
+export interface FilterValidation {
+    readonly v: number;
+    readonly digest: Uint8Array;
+    readonly readsPayload: boolean;
+    readonly readsHeaders: boolean;
+}
+export type FilterErrorReason = "invalid_request" | "unsupported" | "version_skew" | "not_found" | "conflict" | "source_changed" | "membership_stale" | "not_primary" | "catalog_unavailable" | "revision_disabled" | "too_large" | "unauthenticated" | "forbidden" | "unavailable" | "capacity_exhausted" | "backend"
+/** A reason this build does not know. The error's `code` still classifies it. */
+ | "unknown";
+/** A consumer-filter failure as the server reports it. */
+export interface FilterError {
+    readonly code: ResultCode;
+    readonly reason: FilterErrorReason;
+    readonly message: string;
+}
+export type FilterOutcome = {
+    readonly kind: "page";
+    readonly page: FilteredPage;
+} | {
+    readonly kind: "acknowledged";
+    readonly receipt: AckReceipt;
+} | {
+    readonly kind: "preview";
+    readonly preview: FilterPreview;
+} | {
+    readonly kind: "tested";
+    readonly result: FilterTestResult;
+} | {
+    readonly kind: "validated";
+    readonly validation: FilterValidation;
+};
+export type FilterReply = {
+    readonly kind: "ok";
+    readonly outcome: FilterOutcome;
+} | {
+    readonly kind: "err";
+    readonly error: FilterError;
+};
+export type FilterState = "active" | "archived" | "dropped";
+export interface FilterGroupIdentity {
+    readonly streamId: number;
+    readonly streamCreatedAtMicros: bigint;
+    readonly topicId: number;
+    readonly topicCreatedAtMicros: bigint;
+    readonly groupId: bigint;
+}
+export interface FilterGroupRef {
+    readonly stream: string;
+    readonly topic: string;
+    readonly group: string;
+}
+export interface FilterRevisionInfo {
+    readonly enabled: boolean;
+    readonly revision: number;
+    readonly digest: Uint8Array;
+    readonly filter: ConsumerFilter;
+    readonly createdAtMicros: bigint;
+}
+export interface FilterSummary {
+    readonly id: number;
+    readonly name: string;
+    readonly description: string;
+    readonly state: FilterState;
+    readonly latestRevision: number;
+    readonly latestDigest: Uint8Array;
+    readonly codec: FilterCodec;
+    readonly bindings: number;
+    readonly createdAtMicros: bigint;
+    readonly updatedAtMicros: bigint;
+}
+export interface FilterBinding {
+    readonly group: FilterGroupRef;
+    readonly identity: FilterGroupIdentity;
+    readonly filterId: number;
+    readonly revision: number;
+    readonly digest: Uint8Array;
+    readonly boundAtMicros: bigint;
+}
+export interface FilterDetail {
+    readonly summary: FilterSummary;
+    readonly latest: FilterRevisionInfo;
+    readonly bindings: readonly FilterBinding[];
+}
+export type FilterMutation = {
+    readonly kind: "set_revision_enabled";
+    readonly filterId: number;
+    readonly revision: number;
+    readonly enabled: boolean;
+} | {
+    readonly kind: "register";
+    readonly name: string;
+    readonly description: string;
+    readonly filter: ConsumerFilter;
+} | {
+    readonly kind: "revise";
+    readonly filterId: number;
+    readonly expectedRevision: number;
+    readonly filter: ConsumerFilter;
+} | {
+    readonly kind: "describe";
+    readonly filterId: number;
+    readonly description: string;
+} | {
+    readonly kind: "archive";
+    readonly filterId: number;
+} | {
+    readonly kind: "drop";
+    readonly filterId: number;
+} | {
+    readonly kind: "bind";
+    readonly group: FilterGroupRef;
+    readonly filterId: number;
+    readonly revision: number;
+} | {
+    readonly kind: "unbind";
+    readonly group: FilterGroupRef;
+    readonly expectedDigest: Uint8Array;
+    readonly expectedIdentity?: FilterGroupIdentity;
+};
+export interface FilterMutationRequest {
+    readonly v: number;
+    readonly operationId: bigint;
+    readonly mutation: FilterMutation;
+}
+/**
+ * The mutation the catalog appends to its control log, stamped by the
+ * streaming server with the actor and group identity, then by the plane with
+ * the caller's grants and, for a registration, the allocated filter id.
+ */
+export interface FilterCatalogLimits {
+    readonly maxDefinitions: number;
+    readonly maxTombstones: number;
+    readonly maxRevisions: number;
+    readonly maxGroupIdentities: number;
+    /** Encoded bytes of every stored filter revision together. */
+    readonly maxCatalogBytes: bigint;
+}
+export interface FilterCatalogCommand {
+    readonly limits?: FilterCatalogLimits;
+    readonly operationId: bigint;
+    readonly actorUserId: number;
+    readonly mutation: FilterMutation;
+    readonly identity?: FilterGroupIdentity;
+    /** The id a registration takes, allocated before the append. */
+    readonly filterId?: number;
+    /** The grants the mutation is authorized with again when it applies. */
+    readonly grants?: readonly Grant[];
+}
+export interface FilterRevisionRef {
+    readonly filterId: number;
+    readonly revision: number;
+    readonly digest: Uint8Array;
+}
+export type FilterMutationResult = {
+    readonly kind: "revision_state";
+    readonly filterId: number;
+    readonly revision: number;
+    readonly enabled: boolean;
+} | {
+    readonly kind: "registered";
+    readonly revision: FilterRevisionRef;
+} | {
+    readonly kind: "revised";
+    readonly revision: FilterRevisionRef;
+} | {
+    readonly kind: "described";
+    readonly filterId: number;
+} | {
+    readonly kind: "archived";
+    readonly filterId: number;
+} | {
+    readonly kind: "dropped";
+    readonly filterId: number;
+} | {
+    readonly kind: "bound";
+    readonly binding: FilterBinding;
+} | {
+    readonly kind: "unbound";
+    readonly binding: FilterBinding;
+};
+export type FilterMutationStatus = {
+    readonly kind: "pending";
+} | {
+    readonly kind: "applied";
+    readonly result: FilterMutationResult;
+} | {
+    readonly kind: "rejected";
+    readonly error: FilterError;
+};
+export interface FilterMutationOutcome {
+    readonly v: number;
+    readonly operationId: bigint;
+    readonly status: FilterMutationStatus;
+}
+export interface GetFilter {
+    readonly v: number;
+    readonly filterId: number;
+}
+export interface ListFilters {
+    readonly v: number;
+    readonly nameContains?: string;
+    readonly state?: FilterState;
+    /** Only filters with a lower id, so paging stays stable while the catalog changes. */
+    readonly beforeId?: number;
+    readonly page: number;
+    readonly pageSize: number;
+}
+export interface FilterPage {
+    readonly items: readonly FilterSummary[];
+    readonly page: number;
+    readonly pageSize: number;
+    readonly total: number;
+}
+export interface ListFilterRevisions {
+    readonly v: number;
+    readonly filterId: number;
+    readonly page: number;
+    readonly pageSize: number;
+}
+export interface FilterRevisionPage {
+    readonly filterId: number;
+    readonly items: readonly FilterRevisionInfo[];
+    readonly page: number;
+    readonly pageSize: number;
+    readonly total: number;
+}
+export interface GetFilterBinding {
+    readonly v: number;
+    readonly group: FilterGroupRef;
+    readonly identity?: FilterGroupIdentity;
+}
+export interface ListFilterBindings {
+    readonly v: number;
+    readonly filterId?: number;
+    readonly stream?: string;
+    readonly topic?: string;
+    readonly page: number;
+    readonly pageSize: number;
+}
+export interface FilterBindingPage {
+    readonly items: readonly FilterBinding[];
+    readonly page: number;
+    readonly pageSize: number;
+    readonly total: number;
+}
+export interface GetFilterOperation {
+    readonly v: number;
+    readonly operationId: bigint;
+}
+export type FilterPolicyRef = {
+    readonly kind: "revision";
+    readonly filterId: number;
+    readonly revision: number;
+} | {
+    readonly kind: "binding";
+    readonly identity: FilterGroupIdentity;
+};
+export interface ResolveFilterPolicy {
+    readonly allowDisabled?: boolean;
+    readonly v: number;
+    readonly policy: FilterPolicyRef;
+}
+export interface ResolvedFilterPolicy {
+    readonly filterId: number;
+    readonly revision: number;
+    readonly digest: Uint8Array;
+    readonly state: FilterState;
+    readonly filter: ConsumerFilter;
+}
+export type FilterCatalogOutcome = {
+    readonly kind: "filter";
+    readonly detail: FilterDetail;
+} | {
+    readonly kind: "filters";
+    readonly page: FilterPage;
+} | {
+    readonly kind: "revisions";
+    readonly page: FilterRevisionPage;
+} | {
+    readonly kind: "binding";
+    readonly binding: FilterBinding;
+} | {
+    readonly kind: "bindings";
+    readonly page: FilterBindingPage;
+} | {
+    readonly kind: "mutation";
+    readonly outcome: FilterMutationOutcome;
+} | {
+    readonly kind: "policy";
+    readonly policy: ResolvedFilterPolicy;
+};
+export type FilterCatalogReply = {
+    readonly kind: "ok";
+    readonly outcome: FilterCatalogOutcome;
+} | {
+    readonly kind: "err";
+    readonly error: FilterError;
+};
+export declare function validateFilteredPollRequest(request: FilteredPollRequest): void;
+export declare function validateFilteredAck(ack: FilteredAck): void;
+export declare function validateFilterPreviewRequest(request: FilterPreviewRequest): void;
+export declare function validateFilterTestRequest(request: FilterTestRequest): void;
+export declare function validateFilterGroupRef(group: FilterGroupRef): void;
+export declare function validateFilterMutation(mutation: FilterMutation): void;
+export declare function validateFilterMutationRequest(request: FilterMutationRequest): void;
+export declare function validateCatalogPage(page: number, pageSize: number): void;
+export declare function encodeFilterExpr(expr: FilterExpr): Map<string, unknown>;
+export declare function encodeConsumerFilter(filter: ConsumerFilter): Map<string, unknown>;
+export declare function encodeFilterSource(source: FilterSource): Map<string, unknown>;
+export declare function encodeFilterConsumer(consumer: FilterConsumer): Map<string, unknown>;
+export declare function encodeFilterRef(filter: FilterRef): unknown;
+export declare function encodeSourceGeneration(generation: SourceGeneration): Map<string, unknown>;
+export declare function encodeFilteredStart(start: FilteredStart): unknown;
+export declare function encodeFilteredPollRequest(request: FilteredPollRequest): Map<string, unknown>;
+export declare function encodeFilteredAck(ack: FilteredAck): Map<string, unknown>;
+export declare function encodeFilterPreviewRequest(request: FilterPreviewRequest): Map<string, unknown>;
+export declare function encodeHeaderScalar(value: HeaderScalar): Map<string, unknown>;
+export declare function encodeFilterTestRequest(request: FilterTestRequest): Map<string, unknown>;
+export declare function encodeFilteredPage(page: FilteredPage): Map<string, unknown>;
+export declare function encodeFilterError(error: FilterError): Map<string, unknown>;
+export declare function encodeFilterReply(reply: FilterReply): Map<string, unknown>;
+export declare function encodeFilterGroupRef(group: FilterGroupRef): Map<string, unknown>;
+export declare function encodeFilterGroupIdentity(identity: FilterGroupIdentity): Map<string, unknown>;
+export declare function encodeFilterMutation(mutation: FilterMutation): Map<string, unknown>;
+export declare function encodeFilterMutationRequest(request: FilterMutationRequest): Map<string, unknown>;
+export declare function encodeFilterCatalogCommand(command: FilterCatalogCommand): Map<string, unknown>;
+export declare function encodeGetFilter(request: GetFilter): Map<string, unknown>;
+export declare function encodeListFilters(request: ListFilters): Map<string, unknown>;
+export declare function encodeListFilterRevisions(request: ListFilterRevisions): Map<string, unknown>;
+export declare function encodeGetFilterBinding(request: GetFilterBinding): Map<string, unknown>;
+export declare function encodeListFilterBindings(request: ListFilterBindings): Map<string, unknown>;
+export declare function encodeGetFilterOperation(request: GetFilterOperation): Map<string, unknown>;
+export declare function encodeFilterCatalogReply(reply: FilterCatalogReply): Map<string, unknown>;
+export declare function decodeFilterExpr(value: unknown, context: string): FilterExpr;
+export declare function decodeFilterCodec(value: unknown, context: string): FilterCodec;
+export declare function decodeConsumerFilter(value: unknown, context: string): ConsumerFilter;
+export declare function decodeFilterSource(value: unknown, context: string): FilterSource;
+export declare function decodeFilterConsumer(value: unknown, context: string): FilterConsumer;
+export declare function decodeFilterRef(value: unknown, context: string): FilterRef;
+export declare function decodeSourceGeneration(value: unknown, context: string): SourceGeneration;
+export declare function decodeFilteredStart(value: unknown, context: string): FilteredStart;
+export declare function decodeFilteredPollRequest(value: unknown, context: string): FilteredPollRequest;
+export declare function decodeFilteredAck(value: unknown, context: string): FilteredAck;
+export declare function decodeFilteredPage(value: unknown, context: string): FilteredPage;
+export declare function decodeFilterError(value: unknown, context: string): FilterError;
+export declare function decodeFilterReply(value: unknown, context: string): FilterReply;
+export declare function decodeHeaderScalar(value: unknown, context: string): HeaderScalar;
+export declare function decodeFilterGroupRef(value: unknown, context: string): FilterGroupRef;
+export declare function decodeFilterGroupIdentity(value: unknown, context: string): FilterGroupIdentity;
+export declare function decodeFilterMutation(value: unknown, context: string): FilterMutation;
+export declare function decodeFilterMutationRequest(value: unknown, context: string): FilterMutationRequest;
+export declare function decodeFilterCatalogCommand(value: unknown, context: string): FilterCatalogCommand;
+export declare function decodeFilterMutationOutcome(value: unknown, context: string): FilterMutationOutcome;
+export declare function decodeFilterCatalogReply(value: unknown, context: string): FilterCatalogReply;
+export declare function rustDouble(value: number): string;
+/**
+ * Parse JSON the way serde_json does, keeping integers exact. Objects become
+ * maps with the last duplicate key winning. Throws on anything serde_json
+ * rejects. `payload` mode decodes a record payload like the evaluator: only
+ * integers that fit i64 or u64 stay bigints, any other number is a double.
+ * `document` mode keeps every integer a bigint, for u128 fields.
+ */
+export declare function parseCanonicalJson(text: string, mode?: "document" | "payload"): unknown;
+//# sourceMappingURL=filter.d.ts.map