@f-inverse/jammi-client 0.14.0

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

@@ -0,0 +1,739 @@
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file jammi/v1/error.proto.
+ */
+export declare const file_jammi_v1_error: GenFile;
+/**
+ * JammiErrorDetail — the structured domain-error payload a server attaches to
+ * a `tonic::Status` so a remote client can reconstruct the EXACT engine
+ * `JammiError` the in-process path returns, not a lossy gRPC-code-category
+ * guess. Carried in the Status `details` bytes (the gRPC richer-error model);
+ * the Status `code` + `message` still hold the idiomatic gRPC surface for
+ * clients that do not decode the detail.
+ *
+ * The standard gRPC code set is insufficient to distinguish the engine's
+ * failure modes — `invalid_argument` alone collapses Source / Model / Tenant /
+ * Config / Schema / Eval into one code — so a typed detail payload is the
+ * ADR-01 §5.3-sanctioned mechanism for "structured error information when the
+ * standard gRPC code set is insufficient". A typed `oneof` (not a
+ * `google.rpc.Any`) keeps it type-driven: each engine variant reachable on the
+ * embedding/search verb surface has its own message carrying exactly the
+ * fields needed to reconstruct it.
+ *
+ * The contract is complete over `JammiError`: every owned-shape variant — the
+ * String- and struct-carrying ones whose fields fully reconstruct the variant —
+ * has its own typed arm here. `MutableTable` is NOT folded: its inner
+ * `MutableTableError` is engine-owned (every field reconstructs), so it carries
+ * its own structured `MutableTableErrorDetail` and reconstructs faithfully —
+ * the same standard the owned-shape variants meet. The only variants folded
+ * into `other` are the genuinely-foreign `#[from]` ones whose inner error
+ * cannot cross a process boundary (`Io`/`std::io::Error`,
+ * `BackendDriver`/`Toml`/`Json`/`DataFusion`/`Trigger`/`Storage`): they
+ * reconstruct as `JammiError::Other` carrying the faithful `Display` string —
+ * the genuine fidelity limit, not a lossy guess. Faithfulness is a property of
+ * the error type, so the mapping covers the whole enum, not only one verb
+ * surface.
+ *
+ * @generated from message jammi.v1.error.JammiErrorDetail
+ */
+export type JammiErrorDetail = Message<"jammi.v1.error.JammiErrorDetail"> & {
+    /**
+     * @generated from oneof jammi.v1.error.JammiErrorDetail.variant
+     */
+    variant: {
+        /**
+         * @generated from field: jammi.v1.error.SourceError source = 1;
+         */
+        value: SourceError;
+        case: "source";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.ModelError model = 2;
+         */
+        value: ModelError;
+        case: "model";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError inference = 3;
+         */
+        value: StringError;
+        case: "inference";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError catalog = 4;
+         */
+        value: StringError;
+        case: "catalog";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.SchemaError schema = 5;
+         */
+        value: SchemaError;
+        case: "schema";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError config = 6;
+         */
+        value: StringError;
+        case: "config";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError eval = 7;
+         */
+        value: StringError;
+        case: "eval";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError tenant = 8;
+         */
+        value: StringError;
+        case: "tenant";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError other = 9;
+         */
+        value: StringError;
+        case: "other";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError fine_tune = 10;
+         */
+        value: StringError;
+        case: "fineTune";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError gpu = 11;
+         */
+        value: StringError;
+        case: "gpu";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError backend = 12;
+         */
+        value: StringError;
+        case: "backend";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.StringError evidence_channel = 13;
+         */
+        value: StringError;
+        case: "evidenceChannel";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.MutableTableErrorDetail mutable_table = 14;
+         */
+        value: MutableTableErrorDetail;
+        case: "mutableTable";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.error.JammiErrorDetail.
+ * Use `create(JammiErrorDetailSchema)` to create a new message.
+ */
+export declare const JammiErrorDetailSchema: GenMessage<JammiErrorDetail>;
+/**
+ * `JammiError::MutableTable(MutableTableError)`. The inner taxonomy is
+ * engine-owned and every variant's fields reconstruct, so it crosses the wire
+ * faithfully rather than folding to `other`. Each arm carries exactly the
+ * fields the matching `MutableTableError` variant holds; the id-carrying
+ * variants (`not_found`/`already_exists`) carry the table id string, and
+ * `backend` nests the engine-owned `BackendErrorDetail`.
+ *
+ * @generated from message jammi.v1.error.MutableTableErrorDetail
+ */
+export type MutableTableErrorDetail = Message<"jammi.v1.error.MutableTableErrorDetail"> & {
+    /**
+     * @generated from oneof jammi.v1.error.MutableTableErrorDetail.variant
+     */
+    variant: {
+        /**
+         * @generated from field: string invalid_id = 1;
+         */
+        value: string;
+        case: "invalidId";
+    } | {
+        /**
+         * @generated from field: string schema = 2;
+         */
+        value: string;
+        case: "schema";
+    } | {
+        /**
+         * @generated from field: string missing_primary_key = 3;
+         */
+        value: string;
+        case: "missingPrimaryKey";
+    } | {
+        /**
+         * @generated from field: string reserved_column = 4;
+         */
+        value: string;
+        case: "reservedColumn";
+    } | {
+        /**
+         * @generated from field: string not_found = 5;
+         */
+        value: string;
+        case: "notFound";
+    } | {
+        /**
+         * @generated from field: string already_exists = 6;
+         */
+        value: string;
+        case: "alreadyExists";
+    } | {
+        /**
+         * `MutableTableError::NoOrderColumn` carries no payload.
+         *
+         * @generated from field: bool no_order_column = 7;
+         */
+        value: boolean;
+        case: "noOrderColumn";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.BackendErrorDetail backend = 8;
+         */
+        value: BackendErrorDetail;
+        case: "backend";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.error.MutableTableErrorDetail.
+ * Use `create(MutableTableErrorDetailSchema)` to create a new message.
+ */
+export declare const MutableTableErrorDetailSchema: GenMessage<MutableTableErrorDetail>;
+/**
+ * `MutableTableError::Backend(BackendError)`. The backend taxonomy is
+ * engine-owned; every variant but `Sqlx` reconstructs field-for-field. A raw
+ * `sqlx::Error` cannot cross a process boundary, so `Sqlx` is the one arm that
+ * folds to a faithful `Display` string — the genuine fidelity limit, mirroring
+ * how `JammiErrorDetail` folds its own foreign `#[from]` variants.
+ *
+ * @generated from message jammi.v1.error.BackendErrorDetail
+ */
+export type BackendErrorDetail = Message<"jammi.v1.error.BackendErrorDetail"> & {
+    /**
+     * @generated from oneof jammi.v1.error.BackendErrorDetail.variant
+     */
+    variant: {
+        /**
+         * @generated from field: string execution = 1;
+         */
+        value: string;
+        case: "execution";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.ConstraintViolation constraint = 2;
+         */
+        value: ConstraintViolation;
+        case: "constraint";
+    } | {
+        /**
+         * @generated from field: string unavailable = 3;
+         */
+        value: string;
+        case: "unavailable";
+    } | {
+        /**
+         * @generated from field: string retry = 4;
+         */
+        value: string;
+        case: "retry";
+    } | {
+        /**
+         * @generated from field: string migration = 5;
+         */
+        value: string;
+        case: "migration";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.TypeConversion type_conversion = 6;
+         */
+        value: TypeConversion;
+        case: "typeConversion";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.TenantMismatch tenant_mismatch = 7;
+         */
+        value: TenantMismatch;
+        case: "tenantMismatch";
+    } | {
+        /**
+         * `BackendError::Sqlx` — the lone genuinely-foreign arm; its `Display`
+         * string is carried because a `sqlx::Error` does not cross the wire.
+         *
+         * @generated from field: string sqlx = 8;
+         */
+        value: string;
+        case: "sqlx";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.error.BackendErrorDetail.
+ * Use `create(BackendErrorDetailSchema)` to create a new message.
+ */
+export declare const BackendErrorDetailSchema: GenMessage<BackendErrorDetail>;
+/**
+ * `BackendError::Constraint { table, detail }`.
+ *
+ * @generated from message jammi.v1.error.ConstraintViolation
+ */
+export type ConstraintViolation = Message<"jammi.v1.error.ConstraintViolation"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message jammi.v1.error.ConstraintViolation.
+ * Use `create(ConstraintViolationSchema)` to create a new message.
+ */
+export declare const ConstraintViolationSchema: GenMessage<ConstraintViolation>;
+/**
+ * `BackendError::TypeConversion { column, detail }`.
+ *
+ * @generated from message jammi.v1.error.TypeConversion
+ */
+export type TypeConversion = Message<"jammi.v1.error.TypeConversion"> & {
+    /**
+     * @generated from field: string column = 1;
+     */
+    column: string;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message jammi.v1.error.TypeConversion.
+ * Use `create(TypeConversionSchema)` to create a new message.
+ */
+export declare const TypeConversionSchema: GenMessage<TypeConversion>;
+/**
+ * `BackendError::TenantMismatch { table, expected, got }`. The tenant ids are
+ * UUID strings; an empty string means `None` (no tenant on that side).
+ *
+ * @generated from message jammi.v1.error.TenantMismatch
+ */
+export type TenantMismatch = Message<"jammi.v1.error.TenantMismatch"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string expected = 2;
+     */
+    expected: string;
+    /**
+     * @generated from field: string got = 3;
+     */
+    got: string;
+};
+/**
+ * Describes the message jammi.v1.error.TenantMismatch.
+ * Use `create(TenantMismatchSchema)` to create a new message.
+ */
+export declare const TenantMismatchSchema: GenMessage<TenantMismatch>;
+/**
+ * A `JammiError` variant carrying a single human-readable string (`Inference`,
+ * `Catalog`, `Config`, `Eval`, `Tenant`, `FineTune`, `Gpu`, `Backend`,
+ * `EvidenceChannel`, `Other`).
+ *
+ * @generated from message jammi.v1.error.StringError
+ */
+export type StringError = Message<"jammi.v1.error.StringError"> & {
+    /**
+     * @generated from field: string message = 1;
+     */
+    message: string;
+};
+/**
+ * Describes the message jammi.v1.error.StringError.
+ * Use `create(StringErrorSchema)` to create a new message.
+ */
+export declare const StringErrorSchema: GenMessage<StringError>;
+/**
+ * `JammiError::Source { source_id, message }`.
+ *
+ * @generated from message jammi.v1.error.SourceError
+ */
+export type SourceError = Message<"jammi.v1.error.SourceError"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+    /**
+     * @generated from field: string message = 2;
+     */
+    message: string;
+};
+/**
+ * Describes the message jammi.v1.error.SourceError.
+ * Use `create(SourceErrorSchema)` to create a new message.
+ */
+export declare const SourceErrorSchema: GenMessage<SourceError>;
+/**
+ * `JammiError::Model { model_id, message }`.
+ *
+ * @generated from message jammi.v1.error.ModelError
+ */
+export type ModelError = Message<"jammi.v1.error.ModelError"> & {
+    /**
+     * @generated from field: string model_id = 1;
+     */
+    modelId: string;
+    /**
+     * @generated from field: string message = 2;
+     */
+    message: string;
+};
+/**
+ * Describes the message jammi.v1.error.ModelError.
+ * Use `create(ModelErrorSchema)` to create a new message.
+ */
+export declare const ModelErrorSchema: GenMessage<ModelError>;
+/**
+ * `JammiError::Schema { table, column, expected, actual }`.
+ *
+ * @generated from message jammi.v1.error.SchemaError
+ */
+export type SchemaError = Message<"jammi.v1.error.SchemaError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string column = 2;
+     */
+    column: string;
+    /**
+     * @generated from field: string expected = 3;
+     */
+    expected: string;
+    /**
+     * @generated from field: string actual = 4;
+     */
+    actual: string;
+};
+/**
+ * Describes the message jammi.v1.error.SchemaError.
+ * Use `create(SchemaErrorSchema)` to create a new message.
+ */
+export declare const SchemaErrorSchema: GenMessage<SchemaError>;
+/**
+ * TriggerErrorDetail — the structured wire detail for `jammi_db::TriggerError`,
+ * attached to a `tonic::Status` by the server's `map_trigger_error` so a remote
+ * `RemoteSession` reconstructs the EXACT `TriggerError` the in-process path
+ * returns (the standard gRPC code set collapses several variants onto one code).
+ *
+ * The contract is complete and faithful over `TriggerError`. Every owned-shape
+ * variant has its own typed arm. The two `#[from]` variants do NOT fold: their
+ * inner errors are engine-owned and fully reconstructable, so `backing_table`
+ * nests the shared `MutableTableErrorDetail` and `backend` nests the shared
+ * `BackendErrorDetail` — the same faithful taxonomies `JammiErrorDetail` reuses.
+ * No `TriggerError` variant degrades to a lossy string.
+ *
+ * @generated from message jammi.v1.error.TriggerErrorDetail
+ */
+export type TriggerErrorDetail = Message<"jammi.v1.error.TriggerErrorDetail"> & {
+    /**
+     * @generated from oneof jammi.v1.error.TriggerErrorDetail.variant
+     */
+    variant: {
+        /**
+         * @generated from field: string topic_not_found = 1;
+         */
+        value: string;
+        case: "topicNotFound";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.SchemaConflict schema_conflict = 2;
+         */
+        value: SchemaConflict;
+        case: "schemaConflict";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.UnsupportedSchemaType unsupported_schema_type = 3;
+         */
+        value: UnsupportedSchemaType;
+        case: "unsupportedSchemaType";
+    } | {
+        /**
+         * @generated from field: string batch_schema_mismatch = 4;
+         */
+        value: string;
+        case: "batchSchemaMismatch";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.PublishTenantMismatch publish_tenant_mismatch = 5;
+         */
+        value: PublishTenantMismatch;
+        case: "publishTenantMismatch";
+    } | {
+        /**
+         * @generated from field: string predicate_parse = 6;
+         */
+        value: string;
+        case: "predicateParse";
+    } | {
+        /**
+         * @generated from field: string predicate_eval = 7;
+         */
+        value: string;
+        case: "predicateEval";
+    } | {
+        /**
+         * @generated from field: string predicate_unsupported = 8;
+         */
+        value: string;
+        case: "predicateUnsupported";
+    } | {
+        /**
+         * @generated from field: uint64 offset_evicted = 9;
+         */
+        value: bigint;
+        case: "offsetEvicted";
+    } | {
+        /**
+         * `TriggerError::BackingTable(MutableTableError)` — engine-owned, nested
+         * faithfully (never folded to a string).
+         *
+         * @generated from field: jammi.v1.error.MutableTableErrorDetail backing_table = 10;
+         */
+        value: MutableTableErrorDetail;
+        case: "backingTable";
+    } | {
+        /**
+         * `TriggerError::Backend(BackendError)` — engine-owned, nested faithfully.
+         *
+         * @generated from field: jammi.v1.error.BackendErrorDetail backend = 11;
+         */
+        value: BackendErrorDetail;
+        case: "backend";
+    } | {
+        /**
+         * @generated from field: string driver = 12;
+         */
+        value: string;
+        case: "driver";
+    } | {
+        /**
+         * @generated from field: string catalog = 13;
+         */
+        value: string;
+        case: "catalog";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.error.TriggerErrorDetail.
+ * Use `create(TriggerErrorDetailSchema)` to create a new message.
+ */
+export declare const TriggerErrorDetailSchema: GenMessage<TriggerErrorDetail>;
+/**
+ * `TriggerError::SchemaConflict { topic, detail }`.
+ *
+ * @generated from message jammi.v1.error.SchemaConflict
+ */
+export type SchemaConflict = Message<"jammi.v1.error.SchemaConflict"> & {
+    /**
+     * @generated from field: string topic = 1;
+     */
+    topic: string;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message jammi.v1.error.SchemaConflict.
+ * Use `create(SchemaConflictSchema)` to create a new message.
+ */
+export declare const SchemaConflictSchema: GenMessage<SchemaConflict>;
+/**
+ * `TriggerError::UnsupportedSchemaType { column, data_type }`.
+ *
+ * @generated from message jammi.v1.error.UnsupportedSchemaType
+ */
+export type UnsupportedSchemaType = Message<"jammi.v1.error.UnsupportedSchemaType"> & {
+    /**
+     * @generated from field: string column = 1;
+     */
+    column: string;
+    /**
+     * @generated from field: string data_type = 2;
+     */
+    dataType: string;
+};
+/**
+ * Describes the message jammi.v1.error.UnsupportedSchemaType.
+ * Use `create(UnsupportedSchemaTypeSchema)` to create a new message.
+ */
+export declare const UnsupportedSchemaTypeSchema: GenMessage<UnsupportedSchemaType>;
+/**
+ * `TriggerError::PublishTenantMismatch { topic, topic_tenant, publish_tenant }`.
+ * The tenant ids are UUID strings; an empty string means `None` (an unscoped
+ * publish or a global topic).
+ *
+ * @generated from message jammi.v1.error.PublishTenantMismatch
+ */
+export type PublishTenantMismatch = Message<"jammi.v1.error.PublishTenantMismatch"> & {
+    /**
+     * @generated from field: string topic = 1;
+     */
+    topic: string;
+    /**
+     * @generated from field: string topic_tenant = 2;
+     */
+    topicTenant: string;
+    /**
+     * @generated from field: string publish_tenant = 3;
+     */
+    publishTenant: string;
+};
+/**
+ * Describes the message jammi.v1.error.PublishTenantMismatch.
+ * Use `create(PublishTenantMismatchSchema)` to create a new message.
+ */
+export declare const PublishTenantMismatchSchema: GenMessage<PublishTenantMismatch>;
+/**
+ * AuditErrorDetail — the structured wire detail for `jammi_db::AuditError`,
+ * attached to a `tonic::Status` by the server's `map_audit_error` so a remote
+ * `RemoteSession` reconstructs the EXACT `AuditError` the in-process path
+ * returns.
+ *
+ * Every owned-shape variant has its own typed arm and reconstructs faithfully.
+ * The only fold is `serde` — `AuditError::Serde(#[from] serde_json::Error)`
+ * wraps a foreign error that cannot cross a process boundary, so it carries its
+ * faithful `Display` string (the genuine fidelity limit, mirroring how
+ * `JammiErrorDetail` folds its own foreign `#[from]` variants).
+ *
+ * @generated from message jammi.v1.error.AuditErrorDetail
+ */
+export type AuditErrorDetail = Message<"jammi.v1.error.AuditErrorDetail"> & {
+    /**
+     * @generated from oneof jammi.v1.error.AuditErrorDetail.variant
+     */
+    variant: {
+        /**
+         * @generated from field: jammi.v1.error.LengthMismatch length_mismatch = 1;
+         */
+        value: LengthMismatch;
+        case: "lengthMismatch";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.LineageTooLarge lineage_too_large = 2;
+         */
+        value: LineageTooLarge;
+        case: "lineageTooLarge";
+    } | {
+        /**
+         * `AuditError::NoTenantBinding` carries no payload.
+         *
+         * @generated from field: bool no_tenant_binding = 3;
+         */
+        value: boolean;
+        case: "noTenantBinding";
+    } | {
+        /**
+         * `AuditError::SignatureMismatch(Uuid)` — the offending query id (UUID
+         * string).
+         *
+         * @generated from field: string signature_mismatch = 4;
+         */
+        value: string;
+        case: "signatureMismatch";
+    } | {
+        /**
+         * @generated from field: string master_key = 5;
+         */
+        value: string;
+        case: "masterKey";
+    } | {
+        /**
+         * `AuditError::Serde` — the lone genuinely-foreign arm; its `Display`
+         * string is carried because a `serde_json::Error` does not cross the wire.
+         *
+         * @generated from field: string serde = 6;
+         */
+        value: string;
+        case: "serde";
+    } | {
+        /**
+         * @generated from field: string storage = 7;
+         */
+        value: string;
+        case: "storage";
+    } | {
+        /**
+         * @generated from field: string broker = 8;
+         */
+        value: string;
+        case: "broker";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.error.AuditErrorDetail.
+ * Use `create(AuditErrorDetailSchema)` to create a new message.
+ */
+export declare const AuditErrorDetailSchema: GenMessage<AuditErrorDetail>;
+/**
+ * `AuditError::LengthMismatch { ids, scores }`. Both are element counts.
+ *
+ * @generated from message jammi.v1.error.LengthMismatch
+ */
+export type LengthMismatch = Message<"jammi.v1.error.LengthMismatch"> & {
+    /**
+     * @generated from field: uint64 ids = 1;
+     */
+    ids: bigint;
+    /**
+     * @generated from field: uint64 scores = 2;
+     */
+    scores: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.LengthMismatch.
+ * Use `create(LengthMismatchSchema)` to create a new message.
+ */
+export declare const LengthMismatchSchema: GenMessage<LengthMismatch>;
+/**
+ * `AuditError::LineageTooLarge { actual, max }`. Both are byte counts.
+ *
+ * @generated from message jammi.v1.error.LineageTooLarge
+ */
+export type LineageTooLarge = Message<"jammi.v1.error.LineageTooLarge"> & {
+    /**
+     * @generated from field: uint64 actual = 1;
+     */
+    actual: bigint;
+    /**
+     * @generated from field: uint64 max = 2;
+     */
+    max: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.LineageTooLarge.
+ * Use `create(LineageTooLargeSchema)` to create a new message.
+ */
+export declare const LineageTooLargeSchema: GenMessage<LineageTooLarge>;
+//# sourceMappingURL=error_pb.d.ts.map