@omniviewdev/runtime 0.9.2 → 0.11.0

package/dist/bindings/github.com/omniviewdev/plugin-sdk/pkg/resource/v2/models.d.ts

@@ -0,0 +1,809 @@
+import * as json$0 from "../../../../../../encoding/json/models.js";
+/**
+ * AccessRoute selects a configured connection, not an identity or permission.
+ * Connection must be explicit; an empty route never selects a default client.
+ */
+export declare class AccessRoute {
+    "connection": string;
+    /** Creates a new AccessRoute instance. */
+    constructor($$source?: Partial<AccessRoute>);
+    /**
+     * Creates a new AccessRoute instance from a string or object.
+     */
+    static createFrom($$source?: any): AccessRoute;
+}
+/**
+ * ActionDescriptor advertises one named action's presentation and input/output
+ * hints. Catalog action capability and invocation admission remain independent.
+ */
+export declare class ActionDescriptor {
+    "id": string;
+    "label": string;
+    "description": string;
+    "icon": string;
+    "scope": ActionScope;
+    "streaming": boolean;
+    /**
+     * Nil schemas mean no schema was supplied, not that all inputs or outputs
+     * have been validated. Dispatch does not fill defaults from these schemas.
+     */
+    "paramsSchema"?: Schema | null;
+    "outputSchema"?: Schema | null;
+    /**
+     * Dangerous is a UI warning hint, never an authorization decision.
+     */
+    "dangerous"?: boolean;
+    /** Creates a new ActionDescriptor instance. */
+    constructor($$source?: Partial<ActionDescriptor>);
+    /**
+     * Creates a new ActionDescriptor instance from a string or object.
+     */
+    static createFrom($$source?: any): ActionDescriptor;
+}
+/**
+ * ActionScope distinguishes object actions from type-level actions. It is
+ * descriptive metadata, not authority to widen a request's admitted reference.
+ */
+export declare enum ActionScope {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * ActionScopeInstance associates an action with an exact resource reference.
+     */
+    ActionScopeInstance = "instance",
+    /**
+     * ActionScopeType associates an action with a resource type rather than an instance.
+     */
+    ActionScopeType = "type"
+}
+/**
+ * Catalog describes support observed through the requested route. Revision is
+ * an opaque observation used for admission, not an authorization credential.
+ * Failed or denied discovery is an error, not an empty complete catalog.
+ */
+export type Catalog = any;
+/**
+ * CatalogRequest discovers support through one explicit access route. Discovery
+ * does not start a connection or grant authority over the returned types.
+ */
+export declare class CatalogRequest {
+    "route": AccessRoute;
+    /** Creates a new CatalogRequest instance. */
+    constructor($$source?: Partial<CatalogRequest>);
+    /**
+     * Creates a new CatalogRequest instance from a string or object.
+     */
+    static createFrom($$source?: any): CatalogRequest;
+}
+/**
+ * ColumnDefinition describes client-side display and extraction hints. Accessors
+ * are presentation expressions, not canonical addresses or server query predicates.
+ * Maps, ComponentParams, and ResourceLink remain mutable caller-visible metadata.
+ */
+export declare class ColumnDefinition {
+    "id": string;
+    "header": string;
+    "accessor": string;
+    "accessorPriority"?: string;
+    "colorMap"?: {
+        [_ in string]?: string;
+    };
+    "color"?: string;
+    "align"?: string;
+    "hidden"?: boolean;
+    "width"?: number;
+    "formatter"?: string;
+    "component"?: string;
+    "componentParams"?: any;
+    "resourceLink"?: ResourceLink | null;
+    "valueMap"?: {
+        [_ in string]?: string;
+    };
+    /** Creates a new ColumnDefinition instance. */
+    constructor($$source?: Partial<ColumnDefinition>);
+    /**
+     * Creates a new ColumnDefinition instance from a string or object.
+     */
+    static createFrom($$source?: any): ColumnDefinition;
+}
+/**
+ * Count distinguishes unknown cardinality from an observed zero. Unknown requires
+ * nil Value; exact and estimate require a canonical unsigned 64-bit decimal string.
+ * A page's record count does not by itself establish total source cardinality.
+ */
+export declare class Count {
+    "kind": string;
+    "value"?: string | null;
+    /** Creates a new Count instance. */
+    constructor($$source?: Partial<Count>);
+    /**
+     * Creates a new Count instance from a string or object.
+     */
+    static createFrom($$source?: any): Count;
+}
+/**
+ * Coverage states known acquisition limitations, not operation success alone.
+ * Complete forbids Paths and Reason. Partial and unknown require a public-safe
+ * Reason; preserve any reported path limitations rather than claiming completeness.
+ */
+export type Coverage = any;
+/**
+ * EdgeDirection orients a descriptor relative to the source resource.
+ * The empty value is the explicit outgoing direction, not unknown direction.
+ */
+export declare enum EdgeDirection {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * EdgeOutgoing places the source at the origin of the relationship.
+     */
+    EdgeOutgoing = "",
+    /**
+     * EdgeIncoming places the source at the destination of the relationship.
+     */
+    EdgeIncoming = "incoming"
+}
+/**
+ * EditorSchema associates editor selection metadata with an explicit schema
+ * binding. URI is editor metadata, not permission to fetch an external document;
+ * Binding distinguishes unavailable acquisition from known schema absence.
+ */
+export declare class EditorSchema {
+    "type": string;
+    "fileMatch": string;
+    "uri": string;
+    "language": string;
+    "binding": SchemaBinding;
+    /** Creates a new EditorSchema instance. */
+    constructor($$source?: Partial<EditorSchema>);
+    /**
+     * Creates a new EditorSchema instance from a string or object.
+     */
+    static createFrom($$source?: any): EditorSchema;
+}
+/**
+ * EnumerateRequest asks for one finite source page, not a subscription or a
+ * host-planned query result. A valid empty oneOf must return an empty page.
+ */
+export declare class EnumerateRequest {
+    "target": ReadTarget;
+    "pageSize": number;
+    /**
+     * Cursor is nil for an initial acquisition. A nonnil source token is opaque
+     * and must not be reused after the target or source generation changes.
+     */
+    "cursor"?: string | null;
+    /** Creates a new EnumerateRequest instance. */
+    constructor($$source?: Partial<EnumerateRequest>);
+    /**
+     * Creates a new EnumerateRequest instance from a string or object.
+     */
+    static createFrom($$source?: any): EnumerateRequest;
+}
+/**
+ * EventSeverity classifies diagnostic events, not operation errors or watch state.
+ */
+export declare enum EventSeverity {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * SeverityNormal marks informational resource events.
+     */
+    SeverityNormal = "normal",
+    /**
+     * SeverityWarning marks resource events requiring attention.
+     */
+    SeverityWarning = "warning",
+    /**
+     * SeverityError marks resource events reporting a failure.
+     */
+    SeverityError = "error"
+}
+/**
+ * Feature reports availability of an ancillary transport trait, not support for
+ * a finite operation. Finite support always comes from the qualified catalog.
+ */
+export declare enum Feature {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * FeatureConnections enables explicit connection lifecycle operations.
+     */
+    FeatureConnections = "connections",
+    /**
+     * FeatureConnectionReadiness enables nonblocking registered-state inspection.
+     */
+    FeatureConnectionReadiness = "connectionReadiness",
+    /**
+     * FeatureConnectionBrowser enables native configured-profile discovery.
+     */
+    FeatureConnectionBrowser = "connectionBrowser",
+    /**
+     * FeatureConnectionOverlay enables replacement of the desired in-memory profile overlay.
+     */
+    FeatureConnectionOverlay = "connectionOverlay",
+    /**
+     * FeatureScopeValues enables discovery of values for declared scope dimensions.
+     */
+    FeatureScopeValues = "scopeValues",
+    /**
+     * FeaturePresentation enables resource presentation metadata.
+     */
+    FeaturePresentation = "presentation",
+    /**
+     * FeatureEditorSchemas enables editor schema bindings.
+     */
+    FeatureEditorSchemas = "editorSchemas",
+    /**
+     * FeatureSchemaDocuments enables acquisition of shared schema documents.
+     */
+    FeatureSchemaDocuments = "schemaDocuments",
+    /**
+     * FeatureRelationships enables scoped relationship resolution.
+     */
+    FeatureRelationships = "relationships",
+    /**
+     * FeatureHealth enables explicit native health acquisition, not lifecycle readiness.
+     */
+    FeatureHealth = "health",
+    /**
+     * FeatureActionCatalog enables discovery of available action descriptors.
+     */
+    FeatureActionCatalog = "actionCatalog",
+    /**
+     * FeatureStreamingActions enables ready-gated action event streams.
+     */
+    FeatureStreamingActions = "streamingActions",
+    /**
+     * FeatureBestEffortUpdates enables advisory updates without replay guarantees.
+     */
+    FeatureBestEffortUpdates = "bestEffortUpdates"
+}
+/**
+ * FeatureSet lists ancillary traits available on this provider or transport.
+ * Nil or empty Traits advertises none; duplicates and unknown traits are invalid.
+ * Callers must not mutate returned Traits concurrently with SDK use.
+ */
+export declare class FeatureSet {
+    "traits": Feature[];
+    /** Creates a new FeatureSet instance. */
+    constructor($$source?: Partial<FeatureSet>);
+    /**
+     * Creates a new FeatureSet instance from a string or object.
+     */
+    static createFrom($$source?: any): FeatureSet;
+}
+/**
+ * GetRequest selects one reference through a route, with an explicit body format.
+ * Request containers are borrowed for the call; retaining or mutating them
+ * requires an independent copy.
+ */
+export declare class GetRequest {
+    "route": AccessRoute;
+    "reference": ResourceReference;
+    "representation": string;
+    /** Creates a new GetRequest instance. */
+    constructor($$source?: Partial<GetRequest>);
+    /**
+     * Creates a new GetRequest instance from a string or object.
+     */
+    static createFrom($$source?: any): GetRequest;
+}
+/**
+ * HealthCondition retains a provider-defined condition type and status without
+ * interpreting native condition vocabularies. Optional nil times are unknown,
+ * not the zero instant. Reason and Message must be safe for public display.
+ */
+export declare class HealthCondition {
+    "type": string;
+    "status": string;
+    "reason"?: string;
+    "message"?: string;
+    "lastProbeTime"?: string | null;
+    "lastTransitionTime"?: string | null;
+    /** Creates a new HealthCondition instance. */
+    constructor($$source?: Partial<HealthCondition>);
+    /**
+     * Creates a new HealthCondition instance from a string or object.
+     */
+    static createFrom($$source?: any): HealthCondition;
+}
+/**
+ * HealthStatus describes observed resource health, not connection readiness.
+ * Unknown is explicit uncertainty; the zero string is not a health observation.
+ */
+export declare enum HealthStatus {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * HealthHealthy reports normal observed resource health.
+     */
+    HealthHealthy = "healthy",
+    /**
+     * HealthDegraded reports impaired but not wholly failed resource health.
+     */
+    HealthDegraded = "degraded",
+    /**
+     * HealthUnhealthy reports failed resource health.
+     */
+    HealthUnhealthy = "unhealthy",
+    /**
+     * HealthPending reports health assessment or establishment still in progress.
+     */
+    HealthPending = "pending",
+    /**
+     * HealthUnknown explicitly reports insufficient evidence to assess health.
+     */
+    HealthUnknown = "unknown"
+}
+/**
+ * QueryScope intersects constraints across dimensions. Each declared query
+ * dimension must appear exactly once, including unrestricted dimensions.
+ * Nil or empty scope therefore applies only to a type with no query dimensions;
+ * it does not mean all dimensions. Constraint and selection order is immaterial.
+ * JSON requires a nonnull array; Go nil scopes serialize as an empty array.
+ */
+export type QueryScope = any;
+/**
+ * ReadTarget binds a scoped acquisition to an explicit route and host authority.
+ * Representation must already be resolved from catalog metadata; empty is invalid.
+ * Scope selects query dimensions, not merely the dimensions present in identity.
+ */
+export declare class ReadTarget {
+    "route": AccessRoute;
+    "provider": string;
+    "authority": string;
+    "type": string;
+    "scope": QueryScope;
+    "representation": string;
+    /** Creates a new ReadTarget instance. */
+    constructor($$source?: Partial<ReadTarget>);
+    /**
+     * Creates a new ReadTarget instance from a string or object.
+     */
+    static createFrom($$source?: any): ReadTarget;
+}
+/**
+ * Record carries one map-root body with explicit identity, representation, and
+ * coverage provenance. Return independently owned mutable containers; do not
+ * reuse backing maps, slices, or schema bytes while a caller may consume them.
+ */
+export declare class Record {
+    "reference": ResourceReference;
+    "body": Value;
+    "representation": Representation;
+    "coverage": Coverage;
+    /**
+     * SourceRevision optionally observes native content state. Nil makes no
+     * revision claim; a token is opaque and is neither identity nor incarnation.
+     */
+    "sourceRevision"?: string | null;
+    /** Creates a new Record instance. */
+    constructor($$source?: Partial<Record>);
+    /**
+     * Creates a new Record instance from a string or object.
+     */
+    static createFrom($$source?: any): Record;
+}
+/**
+ * RelationshipDescriptor combines observed-link extraction and presentation.
+ * It does not admit a target route, imply enumeration support, or prove that
+ * every possible link has been resolved.
+ */
+export declare class RelationshipDescriptor {
+    "type": RelationshipType;
+    "targetType": string;
+    "label": string;
+    "inverseLabel"?: string;
+    "cardinality"?: string;
+    "direction"?: EdgeDirection;
+    /**
+     * Nil Extractor leaves native resolution to the provider; it is not an
+     * instruction for the host to scan for matching resources.
+     */
+    "extractor"?: RelationshipExtractor | null;
+    /**
+     * TargetScope contains literal dimensions; ScopeExtractors derive the rest.
+     * A dimension must not occur in both or repeat within either collection.
+     */
+    "targetScope": ScopeEntry[];
+    "scopeExtractors": ScopeExtractor[];
+    /** Creates a new RelationshipDescriptor instance. */
+    constructor($$source?: Partial<RelationshipDescriptor>);
+    /**
+     * Creates a new RelationshipDescriptor instance from a string or object.
+     */
+    static createFrom($$source?: any): RelationshipDescriptor;
+}
+/**
+ * RelationshipExtractor describes how native link evidence is found. Native
+ * labels and field values cannot supply target authority or replace host bindings.
+ */
+export declare class RelationshipExtractor {
+    "method": string;
+    "fieldPath"?: string;
+    "labelSelector"?: {
+        [_ in string]?: string;
+    };
+    /** Creates a new RelationshipExtractor instance. */
+    constructor($$source?: Partial<RelationshipExtractor>);
+    /**
+     * Creates a new RelationshipExtractor instance from a string or object.
+     */
+    static createFrom($$source?: any): RelationshipExtractor;
+}
+/**
+ * RelationshipTarget carries independently bound target identity and access.
+ * Route must come from an explicit matching host binding, not source authority.
+ */
+export declare class RelationshipTarget {
+    "reference": ResourceReference;
+    "route": AccessRoute;
+    "displayName"?: string;
+    /** Creates a new RelationshipTarget instance. */
+    constructor($$source?: Partial<RelationshipTarget>);
+    /**
+     * Creates a new RelationshipTarget instance from a string or object.
+     */
+    static createFrom($$source?: any): RelationshipTarget;
+}
+/**
+ * RelationshipType describes the semantic link; it does not authorize following
+ * that link or accessing its target.
+ */
+export declare enum RelationshipType {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * RelOwns links an owner to an owned resource.
+     */
+    RelOwns = "owns",
+    /**
+     * RelRunsOn links a workload to its execution resource.
+     */
+    RelRunsOn = "runs_on",
+    /**
+     * RelUses links a consumer to a dependency.
+     */
+    RelUses = "uses",
+    /**
+     * RelExposes links an exposing resource to the resource it makes accessible.
+     */
+    RelExposes = "exposes",
+    /**
+     * RelManages links a manager to a managed resource.
+     */
+    RelManages = "manages",
+    /**
+     * RelMemberOf links a member to its containing group.
+     */
+    RelMemberOf = "member_of",
+    /**
+     * RelSelects links a selector to a matching resource.
+     */
+    RelSelects = "selects"
+}
+/**
+ * Representation declares a body format and its schema observation. Revision
+ * tracks that format's contract, independently of record or catalog revisions.
+ */
+export declare class Representation {
+    "id": string;
+    "revision": string;
+    "schema": SchemaBinding;
+    /** Creates a new Representation instance. */
+    constructor($$source?: Partial<Representation>);
+    /**
+     * Creates a new Representation instance from a string or object.
+     */
+    static createFrom($$source?: any): Representation;
+}
+/**
+ * ResolvedRelationship returns concrete observed links under one descriptor.
+ * Empty Targets cannot stand in for unsupported resolution or a missing binding.
+ * Result slices and nested descriptor containers must remain stable for callers.
+ */
+export declare class ResolvedRelationship {
+    "descriptor": RelationshipDescriptor;
+    "targets": RelationshipTarget[];
+    /** Creates a new ResolvedRelationship instance. */
+    constructor($$source?: Partial<ResolvedRelationship>);
+    /**
+     * Creates a new ResolvedRelationship instance from a string or object.
+     */
+    static createFrom($$source?: any): ResolvedRelationship;
+}
+/**
+ * ResourceAddress identifies an object independently of the connection used to
+ * access it. Type and ID are opaque; callers must not parse native syntax from
+ * them. Authority is host-issued, not a provider's native authority hint.
+ */
+export type ResourceAddress = any;
+/**
+ * ResourceDefinition supplies display columns without changing record bodies.
+ * Return stable column slices and nested metadata rather than mutable shared buffers.
+ */
+export declare class ResourceDefinition {
+    "columnDefs": ColumnDefinition[];
+    /** Creates a new ResourceDefinition instance. */
+    constructor($$source?: Partial<ResourceDefinition>);
+    /**
+     * Creates a new ResourceDefinition instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceDefinition;
+}
+/**
+ * ResourceEvent is a diagnostic observation, not advisory add/update/delete
+ * delivery or a continuity log. Count cannot be negative and LastSeen must not
+ * precede FirstSeen. Reason, Message, and Source must be safe for public display.
+ */
+export declare class ResourceEvent {
+    "type": EventSeverity;
+    "reason": string;
+    "message": string;
+    "source"?: string;
+    "count"?: number;
+    "firstSeen": string;
+    "lastSeen": string;
+    /** Creates a new ResourceEvent instance. */
+    constructor($$source?: Partial<ResourceEvent>);
+    /**
+     * Creates a new ResourceEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceEvent;
+}
+/**
+ * ResourceGroup organizes opaque resource type IDs for presentation. Group
+ * membership does not add capabilities or change identity and authority.
+ */
+export declare class ResourceGroup {
+    "id": string;
+    "name": string;
+    "description": string;
+    "icon": string;
+    "resources": string[];
+    /** Creates a new ResourceGroup instance. */
+    constructor($$source?: Partial<ResourceGroup>);
+    /**
+     * Creates a new ResourceGroup instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceGroup;
+}
+/**
+ * ResourceHealth is a health observation, independent of lifecycle registration
+ * and finite-operation support. Nil Since means no transition time was supplied;
+ * an empty Conditions slice does not establish healthy status.
+ */
+export declare class ResourceHealth {
+    "status": HealthStatus;
+    "reason"?: string;
+    "message"?: string;
+    "since"?: string | null;
+    "conditions"?: HealthCondition[];
+    /** Creates a new ResourceHealth instance. */
+    constructor($$source?: Partial<ResourceHealth>);
+    /**
+     * Creates a new ResourceHealth instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceHealth;
+}
+/**
+ * ResourceLink is a presentation extractor. Resolved identity is always a
+ * ResourceReference; access routes are supplied independently by the host.
+ */
+export declare class ResourceLink {
+    /**
+     * Type is a literal canonical type. Otherwise TypeAccessor and an explicit
+     * TypeMap translate observed native values; the two selection forms conflict.
+     */
+    "type"?: string;
+    "typeAccessor"?: string;
+    "typeMap"?: {
+        [_ in string]?: string;
+    };
+    "idAccessor": string;
+    "scopeAccessors": ScopeExtractor[];
+    "displayId": boolean;
+    /** Creates a new ResourceLink instance. */
+    constructor($$source?: Partial<ResourceLink>);
+    /**
+     * Creates a new ResourceLink instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceLink;
+}
+/**
+ * ResourceOperationError preserves provider classification across the resource
+ * transport. Title, Message, and Suggestions must contain public-safe text:
+ * never include credentials, private configuration, or raw native diagnostics.
+ * Put native diagnostics in Err, which is excluded from JSON and exposed only
+ * through Unwrap. Error serializes classification and public text, not Err.
+ * The host still owns redaction, canonical AppError provenance, and recovery
+ * policy; provider text and classification never grant permission.
+ */
+export declare class ResourceOperationError {
+    "code": string;
+    "title": string;
+    "message": string;
+    "suggestions"?: string[];
+    /** Creates a new ResourceOperationError instance. */
+    constructor($$source?: Partial<ResourceOperationError>);
+    /**
+     * Creates a new ResourceOperationError instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceOperationError;
+}
+/**
+ * ResourceReference adds an optional native incarnation observation to identity.
+ * A nil Incarnation makes no claim about object recreation; it is not a source
+ * revision or an access route.
+ */
+export declare class ResourceReference {
+    "address": ResourceAddress;
+    "incarnation"?: string | null;
+    /** Creates a new ResourceReference instance. */
+    constructor($$source?: Partial<ResourceReference>);
+    /**
+     * Creates a new ResourceReference instance from a string or object.
+     */
+    static createFrom($$source?: any): ResourceReference;
+}
+/**
+ * Schema is the retained action-schema convenience subset. It is not P07's
+ * normalized resource schema and does not claim support for omitted constraints.
+ */
+export type Schema = any;
+/**
+ * SchemaBinding distinguishes known absence from failed schema acquisition.
+ * Available schemas require a revision, dialect, and exactly one inline Document
+ * or DocumentRef. Absent schemas have no document binding. Unavailable schemas
+ * cannot carry inline documents and must not be reported as absent.
+ * Revisions are opaque equality observations, never object identity.
+ */
+export type SchemaBinding = any;
+/**
+ * SchemaDocument is a bounded raw schema shared by reference across bindings.
+ * Document is not normalized; its mutable bytes must remain stable during use.
+ */
+export declare class SchemaDocument {
+    "reference": SchemaDocumentReference;
+    "dialect": string;
+    "document": json$0.RawMessage;
+    /** Creates a new SchemaDocument instance. */
+    constructor($$source?: Partial<SchemaDocument>);
+    /**
+     * Creates a new SchemaDocument instance from a string or object.
+     */
+    static createFrom($$source?: any): SchemaDocument;
+}
+/**
+ * SchemaDocumentReference shares one bounded raw document across catalog roots.
+ */
+export declare class SchemaDocumentReference {
+    "id": string;
+    "revision": string;
+    /** Creates a new SchemaDocumentReference instance. */
+    constructor($$source?: Partial<SchemaDocumentReference>);
+    /**
+     * Creates a new SchemaDocumentReference instance from a string or object.
+     */
+    static createFrom($$source?: any): SchemaDocumentReference;
+}
+/**
+ * ScopeEntry is one literal identity dimension, not a query constraint.
+ * Empty Value is meaningful only when the declared dimension permits it.
+ */
+export declare class ScopeEntry {
+    "dimension": string;
+    "value": string;
+    /** Creates a new ScopeEntry instance. */
+    constructor($$source?: Partial<ScopeEntry>);
+    /**
+     * Creates a new ScopeEntry instance from a string or object.
+     */
+    static createFrom($$source?: any): ScopeEntry;
+}
+/**
+ * ScopeExtractor explicitly derives a target scope dimension from source data.
+ * TargetScope entries remain literal values; no accessor-string heuristics apply.
+ */
+export declare class ScopeExtractor {
+    "dimension": string;
+    "fieldPath": string;
+    /** Creates a new ScopeExtractor instance. */
+    constructor($$source?: Partial<ScopeExtractor>);
+    /**
+     * Creates a new ScopeExtractor instance from a string or object.
+     */
+    static createFrom($$source?: any): ScopeExtractor;
+}
+/**
+ * Value preserves scalar intent rather than reducing every number to float64.
+ * Kind is null, bool, string, int64, uint64, double, timestamp, list, or map; the
+ * zero Value is invalid. Only the selected payload may be populated. Int and Uint
+ * use canonical decimal strings within their respective 64-bit ranges. Double
+ * must be finite and preserves negative zero. Timestamp uses UTC RFC3339 with
+ * nanosecond precision. A selected nil List or Map is an empty container, not null.
+ * Nested containers remain mutable: copy them before retaining borrowed input
+ * or sharing values with code that may mutate them.
+ */
+export type Value = any;
+/**
+ * WatchConnectionSummary is a source-state observation, not a total inventory.
+ * Resources and ResourceCounts are keyed by opaque resource type; unknown counts
+ * must not be treated as zero or inferred from the number of map entries.
+ */
+export declare class WatchConnectionSummary {
+    "route": AccessRoute;
+    "resources": {
+        [_ in string]?: WatchState;
+    };
+    "resourceCounts": {
+        [_ in string]?: Count;
+    };
+    /**
+     * Scope is optional summary metadata, not permission to widen individual
+     * admitted targets. Nil does not establish unrestricted acquisition.
+     */
+    "scope": QueryScope;
+    "guarantee": string;
+    /** Creates a new WatchConnectionSummary instance. */
+    constructor($$source?: Partial<WatchConnectionSummary>);
+    /**
+     * Creates a new WatchConnectionSummary instance from a string or object.
+     */
+    static createFrom($$source?: any): WatchConnectionSummary;
+}
+/**
+ * WatchState describes one advisory source's lifecycle, not connection health or
+ * source completeness. In particular, synced cannot prove gap-free delivery.
+ */
+export declare enum WatchState {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = 0,
+    /**
+     * WatchStateIdle means the source is registered but has not begun syncing.
+     */
+    WatchStateIdle = 0,
+    /**
+     * WatchStateSyncing means native cache acquisition is in progress.
+     */
+    WatchStateSyncing = 1,
+    /**
+     * WatchStateSynced means the native cache reports readiness, not continuity.
+     */
+    WatchStateSynced = 2,
+    /**
+     * WatchStateError means an attempt failed and may be retried.
+     */
+    WatchStateError = 3,
+    /**
+     * WatchStateStopped means the source ended without a terminal failure.
+     */
+    WatchStateStopped = 4,
+    /**
+     * WatchStateFailed means the source exhausted retries or failed admission.
+     */
+    WatchStateFailed = 5,
+    /**
+     * WatchStateForbidden means source access was denied.
+     */
+    WatchStateForbidden = 6,
+    /**
+     * WatchStateSkipped means startup was intentionally omitted.
+     */
+    WatchStateSkipped = 7
+}