gestalt-sdk 0.0.1-alpha.19

// Code generated by sdkgen. DO NOT EDIT.

//! Generated native types and clients for indexeddb.proto.

use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
use crate::codec::indexeddb::{
    from_wire_count_response, from_wire_cursor_response, from_wire_delete_response,
    from_wire_key_response, from_wire_keys_response, from_wire_record_response,
    from_wire_records_response, from_wire_transaction_server_message,
    to_wire_create_object_store_request, to_wire_cursor_client_message,
    to_wire_delete_object_store_request, to_wire_index_query_request,
    to_wire_object_store_name_request, to_wire_object_store_range_request,
    to_wire_object_store_request, to_wire_record_request, to_wire_transaction_client_message,
};
use crate::generated::v1;
use crate::rpc_support::{GestaltError, RpcStatus};
use tokio_stream::StreamExt;

/// Open enum for `gestalt.provider.v1.CursorDirection`; unknown numeric values are preserved.
pub type CursorDirection = i32;

/// CursorDirection controls IndexedDB cursor traversal order.
///
/// Named values of `CursorDirection`.
pub mod cursor_direction {
    /// CURSOR_NEXT.
    pub const CURSOR_NEXT: i32 = 0;
    /// CURSOR_NEXT_UNIQUE.
    pub const CURSOR_NEXT_UNIQUE: i32 = 1;
    /// CURSOR_PREV.
    pub const CURSOR_PREV: i32 = 2;
    /// CURSOR_PREV_UNIQUE.
    pub const CURSOR_PREV_UNIQUE: i32 = 3;
}

/// Open enum for `gestalt.provider.v1.TransactionDurabilityHint`; unknown numeric values are preserved.
pub type TransactionDurabilityHint = i32;

/// TransactionDurabilityHint mirrors the W3C IndexedDB durability option as a
/// provider hint. It is not a portable durability guarantee.
///
/// Named values of `TransactionDurabilityHint`.
pub mod transaction_durability_hint {
    /// TRANSACTION_DURABILITY_DEFAULT.
    pub const TRANSACTION_DURABILITY_DEFAULT: i32 = 0;
    /// TRANSACTION_DURABILITY_STRICT.
    pub const TRANSACTION_DURABILITY_STRICT: i32 = 1;
    /// TRANSACTION_DURABILITY_RELAXED.
    pub const TRANSACTION_DURABILITY_RELAXED: i32 = 2;
}

/// Open enum for `gestalt.provider.v1.TransactionMode`; unknown numeric values are preserved.
pub type TransactionMode = i32;

/// TransactionMode controls whether a transaction may mutate scoped stores.
///
/// Named values of `TransactionMode`.
pub mod transaction_mode {
    /// TRANSACTION_READONLY.
    pub const TRANSACTION_READONLY: i32 = 0;
    /// TRANSACTION_READWRITE.
    pub const TRANSACTION_READWRITE: i32 = 1;
}

/// BeginTransactionRequest starts an IndexedDB transaction stream.
///
/// Native message type for `gestalt.provider.v1.BeginTransactionRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct BeginTransactionRequest {
    /// The `stores` field.
    pub stores: Vec<String>,
    /// The `mode` field.
    pub mode: TransactionMode,
    /// The `durability_hint` field.
    pub durability_hint: TransactionDurabilityHint,
}

/// ColumnDef is reserved for providers that preserve SQL-style column metadata.
///
/// Native message type for `gestalt.provider.v1.ColumnDef`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ColumnDef {
    /// The `name` field.
    pub name: String,
    /// The `type` field.
    pub r#type: i32,
    /// The `primary_key` field.
    pub primary_key: bool,
    /// The `not_null` field.
    pub not_null: bool,
    /// The `unique` field.
    pub unique: bool,
}

/// CountResponse reports how many rows matched a query.
///
/// Native message type for `gestalt.provider.v1.CountResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CountResponse {
    /// The `count` field.
    pub count: i64,
}

/// CreateObjectStoreRequest creates a new object store.
///
/// Native message type for `gestalt.provider.v1.CreateObjectStoreRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CreateObjectStoreRequest {
    /// The `name` field.
    pub name: String,
    /// The `schema` field; None when unset.
    pub schema: Option<ObjectStoreSchema>,
}

/// Values of the `msg` oneof in `CursorClientMessage`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum CursorClientMessageMsg {
    /// The `open` variant.
    Open(OpenCursorRequest),
    /// The `command` variant.
    Command(CursorCommand),
}

/// CursorClientMessage is one frame in the bidirectional cursor stream.
///
/// Native message type for `gestalt.provider.v1.CursorClientMessage`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CursorClientMessage {
    /// The `msg` oneof; None when unset.
    pub msg: Option<CursorClientMessageMsg>,
}

/// Values of the `command` oneof in `CursorCommand`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum CursorCommandCommand {
    /// The `next` variant.
    Next(bool),
    /// The `continue_to_key` variant.
    ContinueToKey(CursorKeyTarget),
    /// The `advance` variant.
    Advance(i32),
    /// The `update` variant.
    Update(Record),
    /// The `delete` variant.
    Delete(bool),
    /// The `close` variant.
    Close(bool),
}

/// CursorCommand advances, mutates, or closes an open cursor.
///
/// Native message type for `gestalt.provider.v1.CursorCommand`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CursorCommand {
    /// The `command` oneof; None when unset.
    pub command: Option<CursorCommandCommand>,
}

/// CursorEntry is one streamed cursor row.
///
/// Native message type for `gestalt.provider.v1.CursorEntry`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CursorEntry {
    /// Key components per index KeyPath field. Each component is a KeyValue
    /// that can be a scalar or a nested array, preserving the full W3C IndexedDB
    /// key structure including array-valued keys.
    ///
    /// The `key` field.
    pub key: Vec<KeyValue>,
    /// The `primary_key` field.
    pub primary_key: String,
    /// The `record` field; None when unset.
    pub record: Option<Record>,
}

/// CursorKeyTarget addresses a specific cursor position.
///
/// Native message type for `gestalt.provider.v1.CursorKeyTarget`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CursorKeyTarget {
    /// The `key` field.
    pub key: Vec<KeyValue>,
}

/// Values of the `result` oneof in `CursorResponse`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum CursorResponseResult {
    /// The `entry` variant.
    Entry(CursorEntry),
    /// The `done` variant.
    Done(bool),
}

/// CursorResponse is one streamed cursor frame.
///
/// Native message type for `gestalt.provider.v1.CursorResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CursorResponse {
    /// The `result` oneof; None when unset.
    pub result: Option<CursorResponseResult>,
}

/// DeleteObjectStoreRequest removes an object store.
///
/// Native message type for `gestalt.provider.v1.DeleteObjectStoreRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteObjectStoreRequest {
    /// The `name` field.
    pub name: String,
}

/// DeleteResponse reports how many rows were deleted.
///
/// Native message type for `gestalt.provider.v1.DeleteResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteResponse {
    /// The `deleted` field.
    pub deleted: i64,
}

/// IndexQueryRequest addresses a secondary index plus optional key values and
/// range constraints.
///
/// Native message type for `gestalt.provider.v1.IndexQueryRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct IndexQueryRequest {
    /// The `store` field.
    pub store: String,
    /// The `index` field.
    pub index: String,
    /// The `values` field.
    pub values: Vec<TypedValue>,
    /// The `range` field; None when unset.
    pub range: Option<KeyRange>,
}

/// IndexSchema describes one secondary index on an object store.
///
/// Native message type for `gestalt.provider.v1.IndexSchema`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct IndexSchema {
    /// The `name` field.
    pub name: String,
    /// The `key_path` field.
    pub key_path: Vec<String>,
    /// The `unique` field.
    pub unique: bool,
}

/// KeyRange constrains a query or cursor by lower and upper bounds.
///
/// Native message type for `gestalt.provider.v1.KeyRange`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct KeyRange {
    /// The `lower` field; None when unset.
    pub lower: Option<TypedValue>,
    /// The `upper` field; None when unset.
    pub upper: Option<TypedValue>,
    /// The `lower_open` field.
    pub lower_open: bool,
    /// The `upper_open` field.
    pub upper_open: bool,
}

/// KeyResponse wraps one primary key.
///
/// Native message type for `gestalt.provider.v1.KeyResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct KeyResponse {
    /// The `key` field.
    pub key: String,
}

/// Values of the `kind` oneof in `KeyValue`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum KeyValueKind {
    /// The `scalar` variant.
    Scalar(TypedValue),
    /// The `array` variant.
    Array(KeyValueArray),
}

/// KeyValue represents a single IndexedDB key, which can be a scalar
/// (string, number, date, binary) or a nested array of keys per the W3C spec.
///
/// Native message type for `gestalt.provider.v1.KeyValue`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct KeyValue {
    /// The `kind` oneof; None when unset.
    pub kind: Option<KeyValueKind>,
}

/// Native message type for `gestalt.provider.v1.KeyValueArray`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct KeyValueArray {
    /// The `elements` field.
    pub elements: Vec<KeyValue>,
}

/// KeysResponse wraps repeated primary keys.
///
/// Native message type for `gestalt.provider.v1.KeysResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct KeysResponse {
    /// The `keys` field.
    pub keys: Vec<String>,
}

/// ObjectStoreNameRequest addresses an object store without a specific row key.
///
/// Native message type for `gestalt.provider.v1.ObjectStoreNameRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ObjectStoreNameRequest {
    /// The `store` field.
    pub store: String,
}

/// ObjectStoreRangeRequest addresses an object store plus an optional key range.
///
/// Native message type for `gestalt.provider.v1.ObjectStoreRangeRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ObjectStoreRangeRequest {
    /// The `store` field.
    pub store: String,
    /// The `range` field; None when unset.
    pub range: Option<KeyRange>,
}

/// ObjectStoreRequest addresses one object store row by primary key.
///
/// Native message type for `gestalt.provider.v1.ObjectStoreRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ObjectStoreRequest {
    /// The `store` field.
    pub store: String,
    /// The `id` field.
    pub id: String,
}

/// ObjectStoreSchema describes the indexes and columns attached to an object
/// store.
///
/// Native message type for `gestalt.provider.v1.ObjectStoreSchema`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ObjectStoreSchema {
    /// The `indexes` field.
    pub indexes: Vec<IndexSchema>,
    /// The `columns` field.
    pub columns: Vec<ColumnDef>,
}

/// OpenCursorRequest starts a streaming cursor over an object store or index.
///
/// Native message type for `gestalt.provider.v1.OpenCursorRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct OpenCursorRequest {
    /// The `store` field.
    pub store: String,
    /// The `range` field; None when unset.
    pub range: Option<KeyRange>,
    /// The `direction` field.
    pub direction: CursorDirection,
    /// keys_only suppresses row payloads and returns only keys.
    ///
    /// The `keys_only` field.
    pub keys_only: bool,
    /// index selects a secondary index when non-empty.
    ///
    /// The `index` field.
    pub index: String,
    /// values selects a compound index key prefix when index is set.
    ///
    /// The `values` field.
    pub values: Vec<TypedValue>,
}

/// Record is one JSON-like row in an object store.
///
/// Native message type for `gestalt.provider.v1.Record`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Record {
    /// The `fields` field.
    pub fields: std::collections::BTreeMap<String, TypedValue>,
}

/// RecordRequest addresses one object store and carries one row payload.
///
/// Native message type for `gestalt.provider.v1.RecordRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RecordRequest {
    /// The `store` field.
    pub store: String,
    /// The `record` field; None when unset.
    pub record: Option<Record>,
}

/// RecordResponse wraps one row payload.
///
/// Native message type for `gestalt.provider.v1.RecordResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RecordResponse {
    /// The `record` field; None when unset.
    pub record: Option<Record>,
}

/// RecordsResponse wraps repeated row payloads.
///
/// Native message type for `gestalt.provider.v1.RecordsResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RecordsResponse {
    /// The `records` field.
    pub records: Vec<Record>,
}

/// Native message type for `gestalt.provider.v1.TransactionAbortRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionAbortRequest {
    /// The `reason` field.
    pub reason: String,
}

/// TransactionAbortResponse acknowledges abort or reports an abort failure.
///
/// Native message type for `gestalt.provider.v1.TransactionAbortResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionAbortResponse {
    /// The `error` field; None when unset.
    pub error: Option<RpcStatus>,
}

/// Native message type for `gestalt.provider.v1.TransactionBeginResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionBeginResponse {}

/// Values of the `msg` oneof in `TransactionClientMessage`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum TransactionClientMessageMsg {
    /// The `begin` variant.
    Begin(BeginTransactionRequest),
    /// The `operation` variant.
    Operation(TransactionOperation),
    /// The `commit` variant.
    Commit(TransactionCommitRequest),
    /// The `abort` variant.
    Abort(TransactionAbortRequest),
}

/// TransactionClientMessage is one client frame in the transaction stream. The
/// first frame must be BeginTransactionRequest.
///
/// Native message type for `gestalt.provider.v1.TransactionClientMessage`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionClientMessage {
    /// The `msg` oneof; None when unset.
    pub msg: Option<TransactionClientMessageMsg>,
}

/// Native message type for `gestalt.provider.v1.TransactionCommitRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionCommitRequest {}

/// TransactionCommitResponse carries a non-OK status when commit failed after
/// the provider accepted the commit frame and rolled the transaction back.
///
/// Native message type for `gestalt.provider.v1.TransactionCommitResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionCommitResponse {
    /// The `error` field; None when unset.
    pub error: Option<RpcStatus>,
}

/// Values of the `operation` oneof in `TransactionOperation`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum TransactionOperationOperation {
    /// The `get` variant.
    Get(ObjectStoreRequest),
    /// The `get_key` variant.
    GetKey(ObjectStoreRequest),
    /// The `add` variant.
    Add(RecordRequest),
    /// The `put` variant.
    Put(RecordRequest),
    /// The `delete` variant.
    Delete(ObjectStoreRequest),
    /// The `clear` variant.
    Clear(ObjectStoreNameRequest),
    /// The `get_all` variant.
    GetAll(ObjectStoreRangeRequest),
    /// The `get_all_keys` variant.
    GetAllKeys(ObjectStoreRangeRequest),
    /// The `count` variant.
    Count(ObjectStoreRangeRequest),
    /// The `delete_range` variant.
    DeleteRange(ObjectStoreRangeRequest),
    /// The `index_get` variant.
    IndexGet(IndexQueryRequest),
    /// The `index_get_key` variant.
    IndexGetKey(IndexQueryRequest),
    /// The `index_get_all` variant.
    IndexGetAll(IndexQueryRequest),
    /// The `index_get_all_keys` variant.
    IndexGetAllKeys(IndexQueryRequest),
    /// The `index_count` variant.
    IndexCount(IndexQueryRequest),
    /// The `index_delete` variant.
    IndexDelete(IndexQueryRequest),
}

/// TransactionOperation is one ordered transaction-scoped object store or index
/// operation. Cursor operations are intentionally excluded from the initial
/// transaction contract.
///
/// Native message type for `gestalt.provider.v1.TransactionOperation`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionOperation {
    /// The `request_id` field.
    pub request_id: u64,
    /// The `operation` oneof; None when unset.
    pub operation: Option<TransactionOperationOperation>,
}

/// Values of the `result` oneof in `TransactionOperationResponse`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum TransactionOperationResponseResult {
    /// The `empty` variant.
    Empty,
    /// The `record` variant.
    Record(RecordResponse),
    /// The `records` variant.
    Records(RecordsResponse),
    /// The `key` variant.
    Key(KeyResponse),
    /// The `keys` variant.
    Keys(KeysResponse),
    /// The `count` variant.
    Count(CountResponse),
    /// The `delete` variant.
    Delete(DeleteResponse),
}

/// TransactionOperationResponse is the ordered response to one operation.
/// Non-OK error marks the transaction failed and causes rollback in phase 1.
///
/// Native message type for `gestalt.provider.v1.TransactionOperationResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionOperationResponse {
    /// The `request_id` field.
    pub request_id: u64,
    /// The `error` field; None when unset.
    pub error: Option<RpcStatus>,
    /// The `result` oneof; None when unset.
    pub result: Option<TransactionOperationResponseResult>,
}

/// Values of the `msg` oneof in `TransactionServerMessage`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum TransactionServerMessageMsg {
    /// The `begin` variant.
    Begin(TransactionBeginResponse),
    /// The `operation` variant.
    Operation(TransactionOperationResponse),
    /// The `commit` variant.
    Commit(TransactionCommitResponse),
    /// The `abort` variant.
    Abort(TransactionAbortResponse),
}

/// Native message type for `gestalt.provider.v1.TransactionServerMessage`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TransactionServerMessage {
    /// The `msg` oneof; None when unset.
    pub msg: Option<TransactionServerMessageMsg>,
}

/// Values of the `kind` oneof in `TypedValue`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum TypedValueKind {
    /// The `null_value` variant.
    NullValue,
    /// The `string_value` variant.
    StringValue(String),
    /// The `int_value` variant.
    IntValue(i64),
    /// The `float_value` variant.
    FloatValue(f64),
    /// The `bool_value` variant.
    BoolValue(bool),
    /// The `time_value` variant.
    TimeValue(std::time::SystemTime),
    /// The `bytes_value` variant.
    BytesValue(Vec<u8>),
    /// The `json_value` variant.
    JsonValue(serde_json::Value),
}

/// TypedValue stores one scalar or structured value in an IndexedDB record.
///
/// Native message type for `gestalt.provider.v1.TypedValue`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TypedValue {
    /// The `kind` oneof; None when unset.
    pub kind: Option<TypedValueKind>,
}

/// IndexedDB models the shared Gestalt IndexedDB-provider protocol.
///
/// Client for the `gestalt.provider.v1.IndexedDB` service.
pub struct IndexedDB {
    inner: v1::indexed_db_client::IndexedDbClient<HostServiceChannel>,
    timeout: Option<std::time::Duration>,
}

impl IndexedDB {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::indexed_db_client::IndexedDbClient::new(plain_channel(channel)),
            timeout: None,
        }
    }

    /// Sets a deadline applied to every unary call; calls that run past it
    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    /// Connects to the `indexeddb` host service described by the environment.
    pub async fn connect() -> Result<Self, GestaltError> {
        Self::connect_named("").await
    }

    /// Connects to the named `indexeddb` host-service binding.
    pub async fn connect_named(name: &str) -> Result<Self, GestaltError> {
        Ok(Self {
            inner: v1::indexed_db_client::IndexedDbClient::new(
                connect_host_service("indexeddb", name).await?,
            ),
            timeout: None,
        })
    }

    /// Lifecycle
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.CreateObjectStore`.
    pub async fn create_object_store(
        &mut self,
        name: String,
        schema: Option<ObjectStoreSchema>,
    ) -> Result<(), GestaltError> {
        let request = CreateObjectStoreRequest { name, schema };
        let mut tonic_request = tonic::Request::new(to_wire_create_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.create_object_store(tonic_request).await?;
        Ok(())
    }

    /// Lifecycle
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.CreateObjectStore` with the full request and response messages.
    pub async fn create_object_store_raw(
        &mut self,
        request: CreateObjectStoreRequest,
    ) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_create_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.create_object_store(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.DeleteObjectStore`.
    pub async fn delete_object_store(&mut self, name: String) -> Result<(), GestaltError> {
        let request = DeleteObjectStoreRequest { name };
        let mut tonic_request = tonic::Request::new(to_wire_delete_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_object_store(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.DeleteObjectStore` with the full request and response messages.
    pub async fn delete_object_store_raw(
        &mut self,
        request: DeleteObjectStoreRequest,
    ) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_delete_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_object_store(tonic_request).await?;
        Ok(())
    }

    /// Primary key CRUD
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.Get`.
    pub async fn get(&mut self, store: String, id: String) -> Result<RecordResponse, GestaltError> {
        let request = ObjectStoreRequest { store, id };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get(tonic_request).await?;
        Ok(from_wire_record_response(response.into_inner()))
    }

    /// Primary key CRUD
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.Get` with the full request and response messages.
    pub async fn get_raw(
        &mut self,
        request: ObjectStoreRequest,
    ) -> Result<RecordResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get(tonic_request).await?;
        Ok(from_wire_record_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetKey`.
    pub async fn get_key(
        &mut self,
        store: String,
        id: String,
    ) -> Result<KeyResponse, GestaltError> {
        let request = ObjectStoreRequest { store, id };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_key(tonic_request).await?;
        Ok(from_wire_key_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetKey` with the full request and response messages.
    pub async fn get_key_raw(
        &mut self,
        request: ObjectStoreRequest,
    ) -> Result<KeyResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_key(tonic_request).await?;
        Ok(from_wire_key_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Add`.
    pub async fn add(&mut self, store: String, record: Option<Record>) -> Result<(), GestaltError> {
        let request = RecordRequest { store, record };
        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.add(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Add` with the full request and response messages.
    pub async fn add_raw(&mut self, request: RecordRequest) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.add(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Put`.
    pub async fn put(&mut self, store: String, record: Option<Record>) -> Result<(), GestaltError> {
        let request = RecordRequest { store, record };
        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.put(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Put` with the full request and response messages.
    pub async fn put_raw(&mut self, request: RecordRequest) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.put(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Delete`.
    pub async fn delete(&mut self, store: String, id: String) -> Result<(), GestaltError> {
        let request = ObjectStoreRequest { store, id };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Delete` with the full request and response messages.
    pub async fn delete_raw(&mut self, request: ObjectStoreRequest) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete(tonic_request).await?;
        Ok(())
    }

    /// Bulk operations (with optional key range)
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.Clear`.
    pub async fn clear(&mut self, store: String) -> Result<(), GestaltError> {
        let request = ObjectStoreNameRequest { store };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_name_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.clear(tonic_request).await?;
        Ok(())
    }

    /// Bulk operations (with optional key range)
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.Clear` with the full request and response messages.
    pub async fn clear_raw(&mut self, request: ObjectStoreNameRequest) -> Result<(), GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_name_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.clear(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetAll`.
    pub async fn get_all(
        &mut self,
        store: String,
        range: Option<KeyRange>,
    ) -> Result<RecordsResponse, GestaltError> {
        let request = ObjectStoreRangeRequest { store, range };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_all(tonic_request).await?;
        Ok(from_wire_records_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetAll` with the full request and response messages.
    pub async fn get_all_raw(
        &mut self,
        request: ObjectStoreRangeRequest,
    ) -> Result<RecordsResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_all(tonic_request).await?;
        Ok(from_wire_records_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetAllKeys`.
    pub async fn get_all_keys(
        &mut self,
        store: String,
        range: Option<KeyRange>,
    ) -> Result<KeysResponse, GestaltError> {
        let request = ObjectStoreRangeRequest { store, range };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_all_keys(tonic_request).await?;
        Ok(from_wire_keys_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.GetAllKeys` with the full request and response messages.
    pub async fn get_all_keys_raw(
        &mut self,
        request: ObjectStoreRangeRequest,
    ) -> Result<KeysResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_all_keys(tonic_request).await?;
        Ok(from_wire_keys_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Count`.
    pub async fn count(
        &mut self,
        store: String,
        range: Option<KeyRange>,
    ) -> Result<CountResponse, GestaltError> {
        let request = ObjectStoreRangeRequest { store, range };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.count(tonic_request).await?;
        Ok(from_wire_count_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.Count` with the full request and response messages.
    pub async fn count_raw(
        &mut self,
        request: ObjectStoreRangeRequest,
    ) -> Result<CountResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.count(tonic_request).await?;
        Ok(from_wire_count_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.DeleteRange`.
    pub async fn delete_range(
        &mut self,
        store: String,
        range: Option<KeyRange>,
    ) -> Result<DeleteResponse, GestaltError> {
        let request = ObjectStoreRangeRequest { store, range };
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.delete_range(tonic_request).await?;
        Ok(from_wire_delete_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.DeleteRange` with the full request and response messages.
    pub async fn delete_range_raw(
        &mut self,
        request: ObjectStoreRangeRequest,
    ) -> Result<DeleteResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.delete_range(tonic_request).await?;
        Ok(from_wire_delete_response(response.into_inner()))
    }

    /// Index queries
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.IndexGet`.
    pub async fn index_get(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<RecordResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get(tonic_request).await?;
        Ok(from_wire_record_response(response.into_inner()))
    }

    /// Index queries
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.IndexGet` with the full request and response messages.
    pub async fn index_get_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<RecordResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get(tonic_request).await?;
        Ok(from_wire_record_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetKey`.
    pub async fn index_get_key(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<KeyResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_key(tonic_request).await?;
        Ok(from_wire_key_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetKey` with the full request and response messages.
    pub async fn index_get_key_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<KeyResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_key(tonic_request).await?;
        Ok(from_wire_key_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAll`.
    pub async fn index_get_all(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<RecordsResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_all(tonic_request).await?;
        Ok(from_wire_records_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAll` with the full request and response messages.
    pub async fn index_get_all_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<RecordsResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_all(tonic_request).await?;
        Ok(from_wire_records_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAllKeys`.
    pub async fn index_get_all_keys(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<KeysResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_all_keys(tonic_request).await?;
        Ok(from_wire_keys_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAllKeys` with the full request and response messages.
    pub async fn index_get_all_keys_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<KeysResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_get_all_keys(tonic_request).await?;
        Ok(from_wire_keys_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexCount`.
    pub async fn index_count(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<CountResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_count(tonic_request).await?;
        Ok(from_wire_count_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexCount` with the full request and response messages.
    pub async fn index_count_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<CountResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_count(tonic_request).await?;
        Ok(from_wire_count_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexDelete`.
    pub async fn index_delete(
        &mut self,
        store: String,
        index: String,
        values: Vec<TypedValue>,
        range: Option<KeyRange>,
    ) -> Result<DeleteResponse, GestaltError> {
        let request = IndexQueryRequest {
            store,
            index,
            values,
            range,
        };
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_delete(tonic_request).await?;
        Ok(from_wire_delete_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.IndexedDB.IndexDelete` with the full request and response messages.
    pub async fn index_delete_raw(
        &mut self,
        request: IndexQueryRequest,
    ) -> Result<DeleteResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.index_delete(tonic_request).await?;
        Ok(from_wire_delete_response(response.into_inner()))
    }

    /// Cursor iteration (bidirectional stream)
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.OpenCursor`, returning a stream of converted frames.
    pub async fn open_cursor(
        &mut self,
        requests: impl tokio_stream::Stream<Item = CursorClientMessage> + Send + 'static,
    ) -> Result<IndexedDBOpenCursorStream, GestaltError> {
        let response = self
            .inner
            .open_cursor(requests.map(to_wire_cursor_client_message))
            .await?;
        Ok(IndexedDBOpenCursorStream {
            inner: response.into_inner(),
        })
    }

    /// Transaction stream. The first client message must be
    /// BeginTransactionRequest. Stream close before commit aborts the transaction.
    ///
    /// Calls `gestalt.provider.v1.IndexedDB.Transaction`, returning a stream of converted frames.
    pub async fn transaction(
        &mut self,
        requests: impl tokio_stream::Stream<Item = TransactionClientMessage> + Send + 'static,
    ) -> Result<IndexedDBTransactionStream, GestaltError> {
        let response = self
            .inner
            .transaction(requests.map(to_wire_transaction_client_message))
            .await?;
        Ok(IndexedDBTransactionStream {
            inner: response.into_inner(),
        })
    }
}

/// Cursor iteration (bidirectional stream)
///
/// Stream of converted `CursorResponse` frames; transport errors convert to GestaltError.
pub struct IndexedDBOpenCursorStream {
    inner: tonic::Streaming<v1::CursorResponse>,
}

impl IndexedDBOpenCursorStream {
    /// Receives the next frame, or None when the stream ends.
    pub async fn recv(&mut self) -> Result<Option<CursorResponse>, GestaltError> {
        Ok(self.inner.message().await?.map(from_wire_cursor_response))
    }
}

/// Transaction stream. The first client message must be
/// BeginTransactionRequest. Stream close before commit aborts the transaction.
///
/// Stream of converted `TransactionServerMessage` frames; transport errors convert to GestaltError.
pub struct IndexedDBTransactionStream {
    inner: tonic::Streaming<v1::TransactionServerMessage>,
}

impl IndexedDBTransactionStream {
    /// Receives the next frame, or None when the stream ends.
    pub async fn recv(&mut self) -> Result<Option<TransactionServerMessage>, GestaltError> {
        Ok(self
            .inner
            .message()
            .await?
            .map(from_wire_transaction_server_message))
    }
}