@f-inverse/jammi-client 0.24.0 → 0.26.0

package/dist/gen/jammi/v1/catalog_pb.d.ts

@@ -0,0 +1,1148 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { EmptySchema } from "@bufbuild/protobuf/wkt";
+import type { ModelTask } from "./inference_pb";
+import type { ResultTable } from "./embedding_pb";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file jammi/v1/catalog.proto.
+ */
+export declare const file_jammi_v1_catalog: GenFile;
+/**
+ * The engine's self-description, returned by GetServerInfo. `version`,
+ * `features`, and `storage_backends` are compile-time facts about the running
+ * binary; `services` is the runtime tier handshake — which gRPC service tiers
+ * this particular deployment actually mounted. Together they let a client
+ * negotiate capability without probing each verb.
+ *
+ * @generated from message jammi.v1.catalog.ServerInfo
+ */
+export type ServerInfo = Message<"jammi.v1.catalog.ServerInfo"> & {
+    /**
+     * The engine version (the `jammi` workspace version, e.g. "0.17.0").
+     *
+     * @generated from field: string version = 1;
+     */
+    version: string;
+    /**
+     * Engine capability feature flags compiled into this build (e.g. "postgres",
+     * "mysql", "jetstream-broker"), sorted.
+     *
+     * @generated from field: repeated string features = 2;
+     */
+    features: string[];
+    /**
+     * Storage URL schemes this build can address (always "file" and "memory";
+     * cloud schemes appear when their driver feature is compiled in), sorted.
+     *
+     * @generated from field: repeated string storage_backends = 3;
+     */
+    storageBackends: string[];
+    /**
+     * The gRPC service tiers this deployment mounted, sorted. The core tier
+     * (catalog/embedding/inference + introspection) is always present; the
+     * optional tiers ("train", "event", "eval") appear only when both their
+     * compile feature is present and the deployment's config enabled them. A
+     * client reads this to know which verbs are reachable on *this* server —
+     * reaching an unmounted tier returns a truthful "not enabled" error. The
+     * embedded (in-process, `file://`) engine mounts no gRPC services, so it
+     * reports an empty list.
+     *
+     * @generated from field: repeated string services = 4;
+     */
+    services: string[];
+};
+/**
+ * Describes the message jammi.v1.catalog.ServerInfo.
+ * Use `create(ServerInfoSchema)` to create a new message.
+ */
+export declare const ServerInfoSchema: GenMessage<ServerInfo>;
+/**
+ * A tenant identifier carried over the wire. UUID v4 / v7 string per ADR-00;
+ * the nil UUID is invalid and the engine rejects it at the TenantId newtype
+ * boundary.
+ *
+ * @generated from message jammi.v1.catalog.Tenant
+ */
+export type Tenant = Message<"jammi.v1.catalog.Tenant"> & {
+    /**
+     * UUID string. Empty string means "no tenant bound".
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.Tenant.
+ * Use `create(TenantSchema)` to create a new message.
+ */
+export declare const TenantSchema: GenMessage<Tenant>;
+/**
+ * @generated from message jammi.v1.catalog.SetTenantRequest
+ */
+export type SetTenantRequest = Message<"jammi.v1.catalog.SetTenantRequest"> & {
+    /**
+     * @generated from field: jammi.v1.catalog.Tenant tenant = 1;
+     */
+    tenant?: Tenant | undefined;
+};
+/**
+ * Describes the message jammi.v1.catalog.SetTenantRequest.
+ * Use `create(SetTenantRequestSchema)` to create a new message.
+ */
+export declare const SetTenantRequestSchema: GenMessage<SetTenantRequest>;
+/**
+ * @generated from message jammi.v1.catalog.GetTenantResponse
+ */
+export type GetTenantResponse = Message<"jammi.v1.catalog.GetTenantResponse"> & {
+    /**
+     * @generated from field: jammi.v1.catalog.Tenant tenant = 1;
+     */
+    tenant?: Tenant | undefined;
+};
+/**
+ * Describes the message jammi.v1.catalog.GetTenantResponse.
+ * Use `create(GetTenantResponseSchema)` to create a new message.
+ */
+export declare const GetTenantResponseSchema: GenMessage<GetTenantResponse>;
+/**
+ * Connection parameters for a source. Maps onto the engine's
+ * `SourceConnection`; only the fields a wire client needs to register a
+ * file-shaped corpus are exposed (storage URL + format). Cloud credentials
+ * are configured server-side, not carried on the wire.
+ *
+ * @generated from message jammi.v1.catalog.SourceConnection
+ */
+export type SourceConnection = Message<"jammi.v1.catalog.SourceConnection"> & {
+    /**
+     * Storage URL (file://, s3://, gs://, azure://) or external-source
+     * connection string (postgres://, mysql://).
+     *
+     * @generated from field: string url = 1;
+     */
+    url: string;
+    /**
+     * File format — required for a FILE source, ignored otherwise.
+     *
+     * @generated from field: jammi.v1.catalog.FileFormat format = 2;
+     */
+    format: FileFormat;
+};
+/**
+ * Describes the message jammi.v1.catalog.SourceConnection.
+ * Use `create(SourceConnectionSchema)` to create a new message.
+ */
+export declare const SourceConnectionSchema: GenMessage<SourceConnection>;
+/**
+ * @generated from message jammi.v1.catalog.AddSourceRequest
+ */
+export type AddSourceRequest = Message<"jammi.v1.catalog.AddSourceRequest"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+    /**
+     * @generated from field: jammi.v1.catalog.SourceKind source_kind = 2;
+     */
+    sourceKind: SourceKind;
+    /**
+     * @generated from field: jammi.v1.catalog.SourceConnection connection = 3;
+     */
+    connection?: SourceConnection | undefined;
+};
+/**
+ * Describes the message jammi.v1.catalog.AddSourceRequest.
+ * Use `create(AddSourceRequestSchema)` to create a new message.
+ */
+export declare const AddSourceRequestSchema: GenMessage<AddSourceRequest>;
+/**
+ * @generated from message jammi.v1.catalog.RemoveSourceRequest
+ */
+export type RemoveSourceRequest = Message<"jammi.v1.catalog.RemoveSourceRequest"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.RemoveSourceRequest.
+ * Use `create(RemoveSourceRequestSchema)` to create a new message.
+ */
+export declare const RemoveSourceRequestSchema: GenMessage<RemoveSourceRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListSourcesRequest
+ */
+export type ListSourcesRequest = Message<"jammi.v1.catalog.ListSourcesRequest"> & {};
+/**
+ * Describes the message jammi.v1.catalog.ListSourcesRequest.
+ * Use `create(ListSourcesRequestSchema)` to create a new message.
+ */
+export declare const ListSourcesRequestSchema: GenMessage<ListSourcesRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListSourcesResponse
+ */
+export type ListSourcesResponse = Message<"jammi.v1.catalog.ListSourcesResponse"> & {
+    /**
+     * One descriptor per source registered to the calling tenant, in the
+     * engine's registration order.
+     *
+     * @generated from field: repeated jammi.v1.catalog.SourceDescriptor sources = 1;
+     */
+    sources: SourceDescriptor[];
+};
+/**
+ * Describes the message jammi.v1.catalog.ListSourcesResponse.
+ * Use `create(ListSourcesResponseSchema)` to create a new message.
+ */
+export declare const ListSourcesResponseSchema: GenMessage<ListSourcesResponse>;
+/**
+ * @generated from message jammi.v1.catalog.DescribeSourceRequest
+ */
+export type DescribeSourceRequest = Message<"jammi.v1.catalog.DescribeSourceRequest"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.DescribeSourceRequest.
+ * Use `create(DescribeSourceRequestSchema)` to create a new message.
+ */
+export declare const DescribeSourceRequestSchema: GenMessage<DescribeSourceRequest>;
+/**
+ * Registry introspection for one source: its registration identity plus the
+ * embedding result tables produced out of it. The embedding-side
+ * status/row_count/dimensions are carried by the `ResultTable` records
+ * (`result_tables`) — the same shape `GenerateEmbeddings` returns — rather than
+ * duplicated as descriptor fields, so there is one source-of-truth for those
+ * numbers. A freshly-registered source with no embeddings yet carries an empty
+ * `result_tables`.
+ *
+ * @generated from message jammi.v1.catalog.SourceDescriptor
+ */
+export type SourceDescriptor = Message<"jammi.v1.catalog.SourceDescriptor"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+    /**
+     * The storage backend the source was registered with.
+     *
+     * @generated from field: jammi.v1.catalog.SourceKind kind = 2;
+     */
+    kind: SourceKind;
+    /**
+     * Registration lifecycle status from the source catalog (e.g. "active").
+     *
+     * @generated from field: string status = 3;
+     */
+    status: string;
+    /**
+     * Every embedding result table produced from this source. Empty until a
+     * `GenerateEmbeddings` call persists one. Reuses the embedding service's
+     * self-describing `ResultTable` record — the same shape `GenerateEmbeddings`
+     * returns — so the descriptor carries one source-of-truth for those numbers.
+     *
+     * @generated from field: repeated jammi.v1.embedding.ResultTable result_tables = 4;
+     */
+    resultTables: ResultTable[];
+};
+/**
+ * Describes the message jammi.v1.catalog.SourceDescriptor.
+ * Use `create(SourceDescriptorSchema)` to create a new message.
+ */
+export declare const SourceDescriptorSchema: GenMessage<SourceDescriptor>;
+/**
+ * @generated from message jammi.v1.catalog.ListModelsRequest
+ */
+export type ListModelsRequest = Message<"jammi.v1.catalog.ListModelsRequest"> & {};
+/**
+ * Describes the message jammi.v1.catalog.ListModelsRequest.
+ * Use `create(ListModelsRequestSchema)` to create a new message.
+ */
+export declare const ListModelsRequestSchema: GenMessage<ListModelsRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListModelsResponse
+ */
+export type ListModelsResponse = Message<"jammi.v1.catalog.ListModelsResponse"> & {
+    /**
+     * One record per model registered to the calling tenant, in the catalog's
+     * registration order.
+     *
+     * @generated from field: repeated jammi.v1.catalog.Model models = 1;
+     */
+    models: Model[];
+};
+/**
+ * Describes the message jammi.v1.catalog.ListModelsResponse.
+ * Use `create(ListModelsResponseSchema)` to create a new message.
+ */
+export declare const ListModelsResponseSchema: GenMessage<ListModelsResponse>;
+/**
+ * @generated from message jammi.v1.catalog.DescribeModelRequest
+ */
+export type DescribeModelRequest = Message<"jammi.v1.catalog.DescribeModelRequest"> & {
+    /**
+     * @generated from field: string model_id = 1;
+     */
+    modelId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.DescribeModelRequest.
+ * Use `create(DescribeModelRequestSchema)` to create a new message.
+ */
+export declare const DescribeModelRequestSchema: GenMessage<DescribeModelRequest>;
+/**
+ * The client-observable projection of the engine's `ModelRecord`. Carries the
+ * fields a client needs to identify a registered model — its id, the inference
+ * backend, the task it performs, and its lifecycle status. Server-internal
+ * bookkeeping (version counter, derived-from lineage, artifact path, config
+ * blob, registration timestamp) stays server-side, mirroring how `ResultTable`
+ * is the client projection of the engine's result-table record.
+ *
+ * @generated from message jammi.v1.catalog.Model
+ */
+export type Model = Message<"jammi.v1.catalog.Model"> & {
+    /**
+     * Unique model name (e.g. an HF repo id or a fine-tuned id).
+     *
+     * @generated from field: string model_id = 1;
+     */
+    modelId: string;
+    /**
+     * Inference backend (e.g. "candle", "vllm", "http").
+     *
+     * @generated from field: string backend = 2;
+     */
+    backend: string;
+    /**
+     * The task this model performs.
+     *
+     * @generated from field: jammi.v1.inference.ModelTask task = 3;
+     */
+    task: ModelTask;
+    /**
+     * Lifecycle status (e.g. "registered", "loaded", "failed").
+     *
+     * @generated from field: string status = 4;
+     */
+    status: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.Model.
+ * Use `create(ModelSchema)` to create a new message.
+ */
+export declare const ModelSchema: GenMessage<Model>;
+/**
+ * One declared column on a channel. Mirrors the engine's `ChannelColumn`.
+ *
+ * @generated from message jammi.v1.catalog.ChannelColumn
+ */
+export type ChannelColumn = Message<"jammi.v1.catalog.ChannelColumn"> & {
+    /**
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    /**
+     * @generated from field: jammi.v1.catalog.ChannelColumnType data_type = 2;
+     */
+    dataType: ChannelColumnType;
+};
+/**
+ * Describes the message jammi.v1.catalog.ChannelColumn.
+ * Use `create(ChannelColumnSchema)` to create a new message.
+ */
+export declare const ChannelColumnSchema: GenMessage<ChannelColumn>;
+/**
+ * @generated from message jammi.v1.catalog.RegisterChannelRequest
+ */
+export type RegisterChannelRequest = Message<"jammi.v1.catalog.RegisterChannelRequest"> & {
+    /**
+     * Channel id: ASCII slug `[a-z][a-z0-9_]{0,63}`.
+     *
+     * @generated from field: string channel_id = 1;
+     */
+    channelId: string;
+    /**
+     * Resolution priority among channels.
+     *
+     * @generated from field: int32 priority = 2;
+     */
+    priority: number;
+    /**
+     * Ordered columns declared on the channel.
+     *
+     * @generated from field: repeated jammi.v1.catalog.ChannelColumn columns = 3;
+     */
+    columns: ChannelColumn[];
+};
+/**
+ * Describes the message jammi.v1.catalog.RegisterChannelRequest.
+ * Use `create(RegisterChannelRequestSchema)` to create a new message.
+ */
+export declare const RegisterChannelRequestSchema: GenMessage<RegisterChannelRequest>;
+/**
+ * @generated from message jammi.v1.catalog.AddChannelColumnsRequest
+ */
+export type AddChannelColumnsRequest = Message<"jammi.v1.catalog.AddChannelColumnsRequest"> & {
+    /**
+     * @generated from field: string channel_id = 1;
+     */
+    channelId: string;
+    /**
+     * @generated from field: repeated jammi.v1.catalog.ChannelColumn columns = 2;
+     */
+    columns: ChannelColumn[];
+};
+/**
+ * Describes the message jammi.v1.catalog.AddChannelColumnsRequest.
+ * Use `create(AddChannelColumnsRequestSchema)` to create a new message.
+ */
+export declare const AddChannelColumnsRequestSchema: GenMessage<AddChannelColumnsRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListChannelsRequest
+ */
+export type ListChannelsRequest = Message<"jammi.v1.catalog.ListChannelsRequest"> & {};
+/**
+ * Describes the message jammi.v1.catalog.ListChannelsRequest.
+ * Use `create(ListChannelsRequestSchema)` to create a new message.
+ */
+export declare const ListChannelsRequestSchema: GenMessage<ListChannelsRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListChannelsResponse
+ */
+export type ListChannelsResponse = Message<"jammi.v1.catalog.ListChannelsResponse"> & {
+    /**
+     * One entry per channel registered to the calling tenant, ordered by
+     * `(priority, channel_id)`.
+     *
+     * @generated from field: repeated jammi.v1.catalog.Channel channels = 1;
+     */
+    channels: Channel[];
+};
+/**
+ * Describes the message jammi.v1.catalog.ListChannelsResponse.
+ * Use `create(ListChannelsResponseSchema)` to create a new message.
+ */
+export declare const ListChannelsResponseSchema: GenMessage<ListChannelsResponse>;
+/**
+ * A fully-materialized channel in a `ListChannels` response. Carries everything
+ * the engine's `ChannelSpec` holds (id / priority / declared columns) so a
+ * remote `list_channels` reconstructs the identical value the in-process path
+ * returns.
+ *
+ * @generated from message jammi.v1.catalog.Channel
+ */
+export type Channel = Message<"jammi.v1.catalog.Channel"> & {
+    /**
+     * Channel id: ASCII slug `[a-z][a-z0-9_]{0,63}`.
+     *
+     * @generated from field: string channel_id = 1;
+     */
+    channelId: string;
+    /**
+     * Resolution priority among channels.
+     *
+     * @generated from field: int32 priority = 2;
+     */
+    priority: number;
+    /**
+     * Declared columns, in declaration order.
+     *
+     * @generated from field: repeated jammi.v1.catalog.ChannelColumn columns = 3;
+     */
+    columns: ChannelColumn[];
+};
+/**
+ * Describes the message jammi.v1.catalog.Channel.
+ * Use `create(ChannelSchema)` to create a new message.
+ */
+export declare const ChannelSchema: GenMessage<Channel>;
+/**
+ * One secondary-index declaration. Mirrors the engine's `MutableIndexDef`.
+ *
+ * @generated from message jammi.v1.catalog.MutableIndex
+ */
+export type MutableIndex = Message<"jammi.v1.catalog.MutableIndex"> & {
+    /**
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    /**
+     * @generated from field: repeated string columns = 2;
+     */
+    columns: string[];
+    /**
+     * @generated from field: bool unique = 3;
+     */
+    unique: boolean;
+};
+/**
+ * Describes the message jammi.v1.catalog.MutableIndex.
+ * Use `create(MutableIndexSchema)` to create a new message.
+ */
+export declare const MutableIndexSchema: GenMessage<MutableIndex>;
+/**
+ * Registration descriptor for one mutable companion table. Mirrors the Rust
+ * `MutableTableDefinition` (minus `tenant`, which the engine stamps from the
+ * session scope — the wire body stays tenant-free).
+ *
+ * @generated from message jammi.v1.catalog.MutableTableDefinition
+ */
+export type MutableTableDefinition = Message<"jammi.v1.catalog.MutableTableDefinition"> & {
+    /**
+     * Catalog-unique id: lowercase ASCII letters, digits, and `_`, length 1..=63.
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * Arrow schema for the table, encoded as an Arrow IPC schema message (the
+     * same self-describing IPC framing TriggerService uses for batch payloads).
+     *
+     * @generated from field: bytes schema = 2;
+     */
+    schema: Uint8Array;
+    /**
+     * Column(s) forming the primary key. A non-empty subset of the schema.
+     *
+     * @generated from field: repeated string primary_key = 3;
+     */
+    primaryKey: string[];
+    /**
+     * Secondary indexes; one CREATE INDEX per entry.
+     *
+     * @generated from field: repeated jammi.v1.catalog.MutableIndex indexes = 4;
+     */
+    indexes: MutableIndex[];
+    /**
+     * Optional monotonic ordering column for streaming reads (`scan_after`).
+     * Empty == none.
+     *
+     * @generated from field: string order_column = 5;
+     */
+    orderColumn: string;
+    /**
+     * Chunk size for streaming reads. 0 == the engine default (8192).
+     *
+     * @generated from field: uint64 chunk_size = 6;
+     */
+    chunkSize: bigint;
+    /**
+     * Free-form tenant-owned metadata as a JSON object string; "{}" when none.
+     * The engine stores it verbatim and never parses it.
+     *
+     * @generated from field: string user_metadata = 7;
+     */
+    userMetadata: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.MutableTableDefinition.
+ * Use `create(MutableTableDefinitionSchema)` to create a new message.
+ */
+export declare const MutableTableDefinitionSchema: GenMessage<MutableTableDefinition>;
+/**
+ * @generated from message jammi.v1.catalog.CreateMutableTableRequest
+ */
+export type CreateMutableTableRequest = Message<"jammi.v1.catalog.CreateMutableTableRequest"> & {
+    /**
+     * @generated from field: jammi.v1.catalog.MutableTableDefinition definition = 1;
+     */
+    definition?: MutableTableDefinition | undefined;
+};
+/**
+ * Describes the message jammi.v1.catalog.CreateMutableTableRequest.
+ * Use `create(CreateMutableTableRequestSchema)` to create a new message.
+ */
+export declare const CreateMutableTableRequestSchema: GenMessage<CreateMutableTableRequest>;
+/**
+ * @generated from message jammi.v1.catalog.CreateMutableTableResponse
+ */
+export type CreateMutableTableResponse = Message<"jammi.v1.catalog.CreateMutableTableResponse"> & {
+    /**
+     * The id the table was registered under (echoes the validated request id).
+     *
+     * @generated from field: string mutable_table_id = 1;
+     */
+    mutableTableId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.CreateMutableTableResponse.
+ * Use `create(CreateMutableTableResponseSchema)` to create a new message.
+ */
+export declare const CreateMutableTableResponseSchema: GenMessage<CreateMutableTableResponse>;
+/**
+ * @generated from message jammi.v1.catalog.DropMutableTableRequest
+ */
+export type DropMutableTableRequest = Message<"jammi.v1.catalog.DropMutableTableRequest"> & {
+    /**
+     * @generated from field: string mutable_table_id = 1;
+     */
+    mutableTableId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.DropMutableTableRequest.
+ * Use `create(DropMutableTableRequestSchema)` to create a new message.
+ */
+export declare const DropMutableTableRequestSchema: GenMessage<DropMutableTableRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListMutableTablesRequest
+ */
+export type ListMutableTablesRequest = Message<"jammi.v1.catalog.ListMutableTablesRequest"> & {};
+/**
+ * Describes the message jammi.v1.catalog.ListMutableTablesRequest.
+ * Use `create(ListMutableTablesRequestSchema)` to create a new message.
+ */
+export declare const ListMutableTablesRequestSchema: GenMessage<ListMutableTablesRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListMutableTablesResponse
+ */
+export type ListMutableTablesResponse = Message<"jammi.v1.catalog.ListMutableTablesResponse"> & {
+    /**
+     * One definition per mutable table registered to the calling tenant. Each is
+     * the same tenant-free `MutableTableDefinition` shape the create path carries.
+     *
+     * @generated from field: repeated jammi.v1.catalog.MutableTableDefinition definitions = 1;
+     */
+    definitions: MutableTableDefinition[];
+};
+/**
+ * Describes the message jammi.v1.catalog.ListMutableTablesResponse.
+ * Use `create(ListMutableTablesResponseSchema)` to create a new message.
+ */
+export declare const ListMutableTablesResponseSchema: GenMessage<ListMutableTablesResponse>;
+/**
+ * @generated from message jammi.v1.catalog.RegisterTopicRequest
+ */
+export type RegisterTopicRequest = Message<"jammi.v1.catalog.RegisterTopicRequest"> & {
+    /**
+     * Fully-qualified catalog name for the topic.
+     *
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    /**
+     * Arrow schema for batch payloads, encoded as an Arrow IPC schema message
+     * (the same self-describing IPC framing the batch payloads use).
+     *
+     * @generated from field: bytes schema = 2;
+     */
+    schema: Uint8Array;
+    /**
+     * Broker-driver-specific configuration (retention, replication, etc.),
+     * opaque to the engine. Empty == no driver metadata.
+     *
+     * @generated from field: map<string, string> broker_metadata = 3;
+     */
+    brokerMetadata: {
+        [key: string]: string;
+    };
+    /**
+     * Caller-supplied topic id (UUID string). The `Session::register_topic`
+     * surface takes a `TopicDefinition` whose `id` the caller already minted, so
+     * the wire carries it and the server persists *that* id — keeping the topic's
+     * identity (and a later `DropTopic` by id) consistent across the in-process
+     * and remote transports. Empty == server mints a fresh id.
+     *
+     * @generated from field: string topic_id = 4;
+     */
+    topicId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.RegisterTopicRequest.
+ * Use `create(RegisterTopicRequestSchema)` to create a new message.
+ */
+export declare const RegisterTopicRequestSchema: GenMessage<RegisterTopicRequest>;
+/**
+ * @generated from message jammi.v1.catalog.RegisterTopicResponse
+ */
+export type RegisterTopicResponse = Message<"jammi.v1.catalog.RegisterTopicResponse"> & {
+    /**
+     * The engine-minted topic id (UUID string).
+     *
+     * @generated from field: string topic_id = 1;
+     */
+    topicId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.RegisterTopicResponse.
+ * Use `create(RegisterTopicResponseSchema)` to create a new message.
+ */
+export declare const RegisterTopicResponseSchema: GenMessage<RegisterTopicResponse>;
+/**
+ * @generated from message jammi.v1.catalog.DropTopicRequest
+ */
+export type DropTopicRequest = Message<"jammi.v1.catalog.DropTopicRequest"> & {
+    /**
+     * Topic id (UUID string) to drop. The `Session::drop_topic` surface is keyed
+     * by `TopicId`, so the wire carries the id and the server resolves the topic
+     * (tenant-scoped) by it — the same identity the in-process path uses.
+     *
+     * @generated from field: string topic_id = 1;
+     */
+    topicId: string;
+    /**
+     * When true, a missing topic is a no-op instead of a NotFound error.
+     *
+     * @generated from field: bool if_exists = 2;
+     */
+    ifExists: boolean;
+};
+/**
+ * Describes the message jammi.v1.catalog.DropTopicRequest.
+ * Use `create(DropTopicRequestSchema)` to create a new message.
+ */
+export declare const DropTopicRequestSchema: GenMessage<DropTopicRequest>;
+/**
+ * @generated from message jammi.v1.catalog.ListTopicsRequest
+ */
+export type ListTopicsRequest = Message<"jammi.v1.catalog.ListTopicsRequest"> & {
+    /**
+     * AIP-132 pagination.
+     *
+     * @generated from field: int32 page_size = 1;
+     */
+    pageSize: number;
+    /**
+     * @generated from field: string page_token = 2;
+     */
+    pageToken: string;
+    /**
+     * Optional tenant scope filter.
+     *
+     * @generated from field: string tenant_id = 3;
+     */
+    tenantId: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.ListTopicsRequest.
+ * Use `create(ListTopicsRequestSchema)` to create a new message.
+ */
+export declare const ListTopicsRequestSchema: GenMessage<ListTopicsRequest>;
+/**
+ * A fully-materialized topic in a `ListTopics` page. Carries everything a
+ * `TopicDefinition` holds so a remote `Session::list_topics` reconstructs the
+ * identical value the in-process path returns — not just the name.
+ *
+ * @generated from message jammi.v1.catalog.Topic
+ */
+export type Topic = Message<"jammi.v1.catalog.Topic"> & {
+    /**
+     * Engine-minted topic id (UUID string).
+     *
+     * @generated from field: string topic_id = 1;
+     */
+    topicId: string;
+    /**
+     * Fully-qualified catalog name.
+     *
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * Arrow schema for batch payloads, encoded as a self-describing Arrow IPC
+     * schema message (the same framing `RegisterTopicRequest.schema` uses).
+     *
+     * @generated from field: bytes schema = 3;
+     */
+    schema: Uint8Array;
+    /**
+     * Tenant scope (the tenant's canonical string form); empty == global topic.
+     *
+     * @generated from field: string tenant_id = 4;
+     */
+    tenantId: string;
+    /**
+     * Broker-driver-specific configuration, opaque to the engine.
+     *
+     * @generated from field: map<string, string> broker_metadata = 5;
+     */
+    brokerMetadata: {
+        [key: string]: string;
+    };
+};
+/**
+ * Describes the message jammi.v1.catalog.Topic.
+ * Use `create(TopicSchema)` to create a new message.
+ */
+export declare const TopicSchema: GenMessage<Topic>;
+/**
+ * @generated from message jammi.v1.catalog.ListTopicsResponse
+ */
+export type ListTopicsResponse = Message<"jammi.v1.catalog.ListTopicsResponse"> & {
+    /**
+     * @generated from field: repeated jammi.v1.catalog.Topic topics = 1;
+     */
+    topics: Topic[];
+    /**
+     * @generated from field: string next_page_token = 2;
+     */
+    nextPageToken: string;
+};
+/**
+ * Describes the message jammi.v1.catalog.ListTopicsResponse.
+ * Use `create(ListTopicsResponseSchema)` to create a new message.
+ */
+export declare const ListTopicsResponseSchema: GenMessage<ListTopicsResponse>;
+/**
+ * Source backend kind. Mirrors the engine's `SourceType`. The kind is the
+ * storage backend, independent of the content modality embedded out of it.
+ *
+ * @generated from enum jammi.v1.catalog.SourceKind
+ */
+export declare enum SourceKind {
+    /**
+     * @generated from enum value: SOURCE_KIND_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: SOURCE_KIND_FILE = 1;
+     */
+    FILE = 1,
+    /**
+     * @generated from enum value: SOURCE_KIND_POSTGRES = 2;
+     */
+    POSTGRES = 2,
+    /**
+     * @generated from enum value: SOURCE_KIND_MYSQL = 3;
+     */
+    MYSQL = 3
+}
+/**
+ * Describes the enum jammi.v1.catalog.SourceKind.
+ */
+export declare const SourceKindSchema: GenEnum<SourceKind>;
+/**
+ * File format for a file-shaped source. Mirrors the engine's `FileFormat`.
+ *
+ * @generated from enum jammi.v1.catalog.FileFormat
+ */
+export declare enum FileFormat {
+    /**
+     * @generated from enum value: FILE_FORMAT_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: FILE_FORMAT_PARQUET = 1;
+     */
+    PARQUET = 1,
+    /**
+     * @generated from enum value: FILE_FORMAT_CSV = 2;
+     */
+    CSV = 2,
+    /**
+     * @generated from enum value: FILE_FORMAT_JSON = 3;
+     */
+    JSON = 3,
+    /**
+     * @generated from enum value: FILE_FORMAT_AVRO = 4;
+     */
+    AVRO = 4
+}
+/**
+ * Describes the enum jammi.v1.catalog.FileFormat.
+ */
+export declare const FileFormatSchema: GenEnum<FileFormat>;
+/**
+ * The closed set of Arrow types a channel column may declare. Mirrors the
+ * engine's `ChannelColumnType`.
+ *
+ * @generated from enum jammi.v1.catalog.ChannelColumnType
+ */
+export declare enum ChannelColumnType {
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_FLOAT32 = 1;
+     */
+    FLOAT32 = 1,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_FLOAT64 = 2;
+     */
+    FLOAT64 = 2,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_INT32 = 3;
+     */
+    INT32 = 3,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_INT64 = 4;
+     */
+    INT64 = 4,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_UTF8 = 5;
+     */
+    UTF8 = 5,
+    /**
+     * @generated from enum value: CHANNEL_COLUMN_TYPE_BOOLEAN = 6;
+     */
+    BOOLEAN = 6
+}
+/**
+ * Describes the enum jammi.v1.catalog.ChannelColumnType.
+ */
+export declare const ChannelColumnTypeSchema: GenEnum<ChannelColumnType>;
+/**
+ * CatalogService — the engine's single control-plane surface: every
+ * catalog / metadata / lifecycle / observability RPC a remote client reaches.
+ * The verbs are imperative session methods (registry reads + lifecycle
+ * mutations), not SQL queries, so they live as typed gRPC RPCs distinct from
+ * the Flight SQL data-plane (which carries query/result only, per ADR-01
+ * §3.2) and the compute/stream data-plane services (embedding / inference /
+ * training / eval / pipeline / trigger / audit).
+ *
+ * Each verb delegates 1:1 to the consumer-facing `Session`
+ * abstraction; the service reimplements no catalog or lifecycle logic. The
+ * service spans five control concerns. Session: `SetTenant` / `GetTenant` /
+ * `ClearTenant` bind, read, and clear the calling session's tenant, and
+ * `GetServerInfo` is the capability handshake — the tenant trio is stateless
+ * w.r.t. the engine (it updates an in-process session table the
+ * TenantInterceptor reads on every downstream request) and `GetServerInfo`
+ * reports compile-time facts plus the runtime tier set, so both mount on the
+ * always-present core tier. Sources / models: `AddSource` / `RemoveSource` /
+ * `ListSources` / `DescribeSource` register and introspect data sources, and
+ * `ListModels` / `DescribeModel` introspect the model catalog. Channels:
+ * `RegisterChannel` / `AddChannelColumns` / `ListChannels` declare and
+ * introspect provenance channels. Mutable tables: `CreateMutableTable` /
+ * `DropMutableTable` / `ListMutableTables` register and introspect mutable
+ * companion tables. Topics: `RegisterTopic` / `DropTopic` / `ListTopics`
+ * register and introspect trigger-stream topics (the publish / subscribe
+ * compute verbs stay on TriggerService).
+ *
+ * Tenant scope is read from the request's `SessionTenant` extension, set by
+ * the shared TenantInterceptor from the `jammi-session-id` header — the same
+ * mechanism every other gRPC service and Flight SQL use.
+ *
+ * --- session -----------------------------------------------------------
+ *
+ * @generated from service jammi.v1.catalog.CatalogService
+ */
+export declare const CatalogService: GenService<{
+    /**
+     * Bind a tenant for the calling session. Idempotent — calling twice with
+     * the same tenant is a no-op. Replacing an existing binding is allowed
+     * (the auth layer above the engine validates the caller is permitted).
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.SetTenant
+     */
+    setTenant: {
+        methodKind: "unary";
+        input: typeof SetTenantRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * Return the tenant currently bound to the calling session, or an unset
+     * tenant if none is bound.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.GetTenant
+     */
+    getTenant: {
+        methodKind: "unary";
+        input: typeof EmptySchema;
+        output: typeof GetTenantResponseSchema;
+    };
+    /**
+     * Clear the tenant binding for the calling session. After this returns,
+     * subsequent requests on the same session see an unscoped tenant.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ClearTenant
+     */
+    clearTenant: {
+        methodKind: "unary";
+        input: typeof EmptySchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * Capabilities handshake: the engine's version, the feature flags this
+     * build was compiled with, and the storage backends it can address. Static
+     * per build, tenant-agnostic, and engine-independent.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.GetServerInfo
+     */
+    getServerInfo: {
+        methodKind: "unary";
+        input: typeof EmptySchema;
+        output: typeof ServerInfoSchema;
+    };
+    /**
+     * Register a data source so a later GenerateEmbeddings call can scan it.
+     * Peer of the abstraction's `add_source`. The source carries any modality
+     * the engine supports; the kind here is the storage backend, not the
+     * content modality. Idempotent only insofar as the engine allows —
+     * re-registering an id that already exists is an error.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.AddSource
+     */
+    addSource: {
+        methodKind: "unary";
+        input: typeof AddSourceRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * Remove a registered source and all associated state (embedding tables,
+     * indexes). Peer of the abstraction's `remove_source`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.RemoveSource
+     */
+    removeSource: {
+        methodKind: "unary";
+        input: typeof RemoveSourceRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * List a `SourceDescriptor` for every source registered to the calling
+     * tenant. Peer of the abstraction's `list_sources`; registry introspection,
+     * not a SQL query. `ListSources` is `DescribeSource` applied over every
+     * registered source — one descriptor shape, one operator, no per-source
+     * special-casing.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ListSources
+     */
+    listSources: {
+        methodKind: "unary";
+        input: typeof ListSourcesRequestSchema;
+        output: typeof ListSourcesResponseSchema;
+    };
+    /**
+     * Describe one registered source: its registry identity (id / kind /
+     * lifecycle status) plus the result tables embedded out of it (each carrying
+     * its own status / row_count / dimensions). Peer of the abstraction's
+     * `describe_source`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.DescribeSource
+     */
+    describeSource: {
+        methodKind: "unary";
+        input: typeof DescribeSourceRequestSchema;
+        output: typeof SourceDescriptorSchema;
+    };
+    /**
+     * List a `Model` record for every model registered to the calling tenant.
+     * Peer of the abstraction's `list_models`; registry introspection, not a SQL
+     * query.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ListModels
+     */
+    listModels: {
+        methodKind: "unary";
+        input: typeof ListModelsRequestSchema;
+        output: typeof ListModelsResponseSchema;
+    };
+    /**
+     * Describe one registered model by id: the same `Model` projection
+     * `ListModels` carries, for the latest registered version. Peer of the
+     * abstraction's `describe_model`. An absent model returns NotFound.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.DescribeModel
+     */
+    describeModel: {
+        methodKind: "unary";
+        input: typeof DescribeModelRequestSchema;
+        output: typeof ModelSchema;
+    };
+    /**
+     * Register a provenance channel and its initial columns. Peer of the
+     * abstraction's `register_channel`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.RegisterChannel
+     */
+    registerChannel: {
+        methodKind: "unary";
+        input: typeof RegisterChannelRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * Append columns to an already-registered channel (append-only). Peer of the
+     * abstraction's `add_channel_columns`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.AddChannelColumns
+     */
+    addChannelColumns: {
+        methodKind: "unary";
+        input: typeof AddChannelColumnsRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * List every channel registered to the calling tenant, ordered by
+     * `(priority, channel_id)`. Peer of the abstraction's `list_channels`;
+     * registry introspection, not a SQL query.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ListChannels
+     */
+    listChannels: {
+        methodKind: "unary";
+        input: typeof ListChannelsRequestSchema;
+        output: typeof ListChannelsResponseSchema;
+    };
+    /**
+     * Register a mutable companion table. After this returns the table is
+     * queryable through Flight SQL. Peer of the abstraction's
+     * `create_mutable_table`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.CreateMutableTable
+     */
+    createMutableTable: {
+        methodKind: "unary";
+        input: typeof CreateMutableTableRequestSchema;
+        output: typeof CreateMutableTableResponseSchema;
+    };
+    /**
+     * Drop a mutable companion table. Peer of the abstraction's
+     * `drop_mutable_table`.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.DropMutableTable
+     */
+    dropMutableTable: {
+        methodKind: "unary";
+        input: typeof DropMutableTableRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * List every mutable companion table registered to the calling tenant. Peer
+     * of the abstraction's `list_mutable_tables`; registry introspection, not a
+     * SQL query. Each entry is the same `MutableTableDefinition` the create path
+     * carries (minus tenant, which rides the session scope).
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ListMutableTables
+     */
+    listMutableTables: {
+        methodKind: "unary";
+        input: typeof ListMutableTablesRequestSchema;
+        output: typeof ListMutableTablesResponseSchema;
+    };
+    /**
+     * Register a topic (provisions its backing table) for the trigger stream.
+     * Peer of the abstraction's `register_topic`. The schema is the contract
+     * every published batch must satisfy.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.RegisterTopic
+     */
+    registerTopic: {
+        methodKind: "unary";
+        input: typeof RegisterTopicRequestSchema;
+        output: typeof RegisterTopicResponseSchema;
+    };
+    /**
+     * Drop a topic and its backing table. Peer of the abstraction's
+     * `drop_topic`. `if_exists` makes a missing topic a no-op rather than a
+     * NotFound error.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.DropTopic
+     */
+    dropTopic: {
+        methodKind: "unary";
+        input: typeof DropTopicRequestSchema;
+        output: typeof EmptySchema;
+    };
+    /**
+     * List topics registered in the catalog. Pagination follows AIP-132.
+     *
+     * @generated from rpc jammi.v1.catalog.CatalogService.ListTopics
+     */
+    listTopics: {
+        methodKind: "unary";
+        input: typeof ListTopicsRequestSchema;
+        output: typeof ListTopicsResponseSchema;
+    };
+}>;
+//# sourceMappingURL=catalog_pb.d.ts.map