gestalt-sdk 0.0.1-alpha.26

// Code generated by sdkgen. DO NOT EDIT.

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

use crate::codec::app::{
    from_wire_get_session_catalog_response, from_wire_invoke_frame, from_wire_operation_result,
    from_wire_provider_metadata, from_wire_resolve_http_subject_response,
    from_wire_start_provider_response, to_wire_app_invoke_graphql_request,
    to_wire_app_invoke_request, to_wire_execute_request, to_wire_get_session_catalog_request,
    to_wire_resolve_http_subject_request, to_wire_start_provider_request,
};
use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
use crate::generated::v1;
use crate::invoke_support::{InvokeError, decode_app_result};
use crate::rpc_support::GestaltError;

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

/// ConnectionMode describes which credential sources a provider accepts.
///
/// Named values of `ConnectionMode`.
pub mod connection_mode {
    /// CONNECTION_MODE_UNSPECIFIED.
    pub const CONNECTION_MODE_UNSPECIFIED: i32 = 0;
    /// CONNECTION_MODE_NONE.
    pub const CONNECTION_MODE_NONE: i32 = 1;
    /// CONNECTION_MODE_SUBJECT.
    pub const CONNECTION_MODE_SUBJECT: i32 = 2;
}

/// AccessContext describes the host-side access decision for an operation.
///
/// Native message type for `gestalt.provider.v1.AccessContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AccessContext {
    /// The `policy` field.
    pub policy: String,
    /// The `role` field.
    pub role: String,
}

/// Native message type for `gestalt.provider.v1.AgentInvocationContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentInvocationContext {
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `session_id` field.
    pub session_id: String,
    /// The `turn_id` field.
    pub turn_id: String,
}

/// Native message type for `gestalt.provider.v1.AgentToolRef`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentToolRef {
    /// The `app` field.
    pub app: String,
    /// The `operation` field.
    pub operation: String,
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `title` field.
    pub title: String,
    /// The `description` field.
    pub description: String,
    /// The `credential_mode` field.
    pub credential_mode: String,
    /// The `system` field.
    pub system: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
}

/// AppInvokeGraphQLRequest invokes the raw GraphQL surface on another plugin
/// through Gestalt.
///
/// Native message type for `gestalt.provider.v1.AppInvokeGraphQLRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppInvokeGraphQLRequest {
    /// The `app` field.
    pub app: String,
    /// The `document` field.
    pub document: String,
    /// The `variables` field; None when unset.
    pub variables: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
    /// headers overrides outbound static headers declared by the target provider.
    ///
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, String>,
}

/// AppInvokeRequest invokes a declared operation on another app through Gestalt.
///
/// Native message type for `gestalt.provider.v1.AppInvokeRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppInvokeRequest {
    /// The `app` field.
    pub app: String,
    /// The `operation` field.
    pub operation: String,
    /// The `params` field; None when unset.
    pub params: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `credential_mode` field.
    pub credential_mode: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// headers overrides outbound static headers declared by the target provider.
    ///
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, String>,
}

/// Catalog is the static or request-scoped executable surface exposed by a
/// provider.
///
/// Native message type for `gestalt.provider.v1.Catalog`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Catalog {
    /// The `name` field.
    pub name: String,
    /// The `display_name` field.
    pub display_name: String,
    /// The `description` field.
    pub description: String,
    /// The `icon_svg` field.
    pub icon_svg: String,
    /// The `operations` field.
    pub operations: Vec<CatalogOperation>,
}

/// CatalogOperation is one executable operation exposed by an integration
/// provider.
///
/// Native message type for `gestalt.provider.v1.CatalogOperation`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalogOperation {
    /// The `id` field.
    pub id: String,
    /// The `method` field.
    pub method: String,
    /// The `title` field.
    pub title: String,
    /// The `description` field.
    pub description: String,
    /// The `input_schema` field.
    pub input_schema: String,
    /// The `annotations` field; None when unset.
    pub annotations: Option<OperationAnnotations>,
    /// The `parameters` field.
    pub parameters: Vec<CatalogParameter>,
    /// The `required_scopes` field.
    pub required_scopes: Vec<String>,
    /// The `tags` field.
    pub tags: Vec<String>,
    /// The `read_only` field.
    pub read_only: bool,
    /// The `visible` field; None when unset.
    pub visible: Option<bool>,
    /// The `transport` field.
    pub transport: String,
    /// The `allowed_roles` field.
    pub allowed_roles: Vec<String>,
    /// Response mode and schema for this operation. Replaces the former
    /// output_schema string; absent is equivalent to unary with no schema.
    ///
    /// The `response` field; None when unset.
    pub response: Option<OperationResponseSpec>,
}

/// CatalogParameter describes one input parameter surfaced in the generated
/// catalog for an operation.
///
/// Native message type for `gestalt.provider.v1.CatalogParameter`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalogParameter {
    /// The `name` field.
    pub name: String,
    /// The `type` field.
    pub r#type: String,
    /// The `description` field.
    pub description: String,
    /// The `required` field.
    pub required: bool,
    /// The `default` field; None when unset.
    pub default: Option<serde_json::Value>,
}

/// ConnectionParamDef describes one provider-defined connection parameter.
///
/// Native message type for `gestalt.provider.v1.ConnectionParamDef`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionParamDef {
    /// The `required` field.
    pub required: bool,
    /// The `description` field.
    pub description: String,
    /// The `default_value` field.
    pub default_value: String,
    /// The `from` field.
    pub from: String,
    /// The `field` field.
    pub field: String,
}

/// CredentialContext describes the resolved credential used for an operation.
///
/// Native message type for `gestalt.provider.v1.CredentialContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CredentialContext {
    /// The `mode` field.
    pub mode: String,
    /// The `subject_id` field.
    pub subject_id: String,
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
}

/// ExecuteRequest invokes one executable operation.
///
/// Native message type for `gestalt.provider.v1.ExecuteRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExecuteRequest {
    /// The `operation` field.
    pub operation: String,
    /// The `params` field; None when unset.
    pub params: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `token` field.
    pub token: String,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, String>,
    /// The `invocation_id` field.
    pub invocation_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
}

/// GetSessionCatalogRequest asks a provider for request-scoped catalog
/// extensions.
///
/// Native message type for `gestalt.provider.v1.GetSessionCatalogRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetSessionCatalogRequest {
    /// The `token` field.
    pub token: String,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, String>,
    /// The `invocation_id` field.
    pub invocation_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// GetSessionCatalogResponse returns request-scoped catalog extensions.
///
/// Native message type for `gestalt.provider.v1.GetSessionCatalogResponse`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetSessionCatalogResponse {
    /// The `catalog` field; None when unset.
    pub catalog: Option<Catalog>,
}

/// HTTPSubjectRequest carries one verified hosted HTTP request into an optional
/// plugin-local subject resolution hook.
///
/// Native message type for `gestalt.provider.v1.HTTPSubjectRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HTTPSubjectRequest {
    /// The `binding` field.
    pub binding: String,
    /// The `method` field.
    pub method: String,
    /// The `path` field.
    pub path: String,
    /// The `content_type` field.
    pub content_type: String,
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, StringList>,
    /// The `query` field.
    pub query: std::collections::BTreeMap<String, StringList>,
    /// The `params` field; None when unset.
    pub params: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `raw_body` field.
    pub raw_body: Vec<u8>,
    /// The `security_scheme` field.
    pub security_scheme: String,
    /// The `verified_subject` field.
    pub verified_subject: String,
    /// The `verified_claims` field.
    pub verified_claims: std::collections::BTreeMap<String, String>,
}

/// HostContext describes stable public host metadata available to provider code.
///
/// Native message type for `gestalt.provider.v1.HostContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HostContext {
    /// The `public_base_url` field.
    pub public_base_url: String,
}

/// Native message type for `gestalt.provider.v1.InvocationContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InvocationContext {
    /// The `request_id` field.
    pub request_id: String,
    /// The `depth` field.
    pub depth: i32,
    /// The `call_chain` field.
    pub call_chain: Vec<String>,
    /// The `surface` field.
    pub surface: String,
    /// The `internal_connection_access` field.
    pub internal_connection_access: bool,
    /// The `connection` field.
    pub connection: String,
}

/// Values of the `value` oneof in `InvokeFrame`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum InvokeFrameValue {
    /// The `metadata` variant.
    Metadata(InvokeMetadata),
    /// The `data` variant.
    Data(Vec<u8>),
}

/// InvokeFrame is one frame in a streaming invocation. The first frame is always
/// metadata; subsequent frames carry data bytes produced by the operation
/// handler (after encoding, for typed item streams). A mid-stream error (for
/// example, a validation failure or a recovered panic) may emit a trailing
/// metadata frame with a non-2xx status followed by a data frame carrying a
/// JSON error body, after which the stream ends.
///
/// Native message type for `gestalt.provider.v1.InvokeFrame`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InvokeFrame {
    /// The `value` oneof; None when unset.
    pub value: Option<InvokeFrameValue>,
}

/// InvokeMetadata is the first frame of a streaming invocation. It carries the
/// HTTP-shaped status, headers, and the response media type (from the
/// operation's StreamResponseSpec).
///
/// Native message type for `gestalt.provider.v1.InvokeMetadata`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InvokeMetadata {
    /// The `status` field.
    pub status: i32,
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, StringList>,
    /// The `media_type` field.
    pub media_type: String,
}

/// OperationAnnotations carries optional host hints about how an operation
/// behaves.
///
/// Native message type for `gestalt.provider.v1.OperationAnnotations`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OperationAnnotations {
    /// The `read_only_hint` field; None when unset.
    pub read_only_hint: Option<bool>,
    /// The `idempotent_hint` field; None when unset.
    pub idempotent_hint: Option<bool>,
    /// The `destructive_hint` field; None when unset.
    pub destructive_hint: Option<bool>,
    /// The `open_world_hint` field; None when unset.
    pub open_world_hint: Option<bool>,
}

/// Values of the `kind` oneof in `OperationResponseSpec`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum OperationResponseSpecKind {
    /// The `unary` variant.
    Unary(UnaryResponseSpec),
    /// The `stream` variant.
    Stream(StreamResponseSpec),
}

/// OperationResponseSpec declares how an operation responds. App authoring
/// defaults to unary; emitted catalogs always declare either unary or stream.
///
/// Native message type for `gestalt.provider.v1.OperationResponseSpec`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OperationResponseSpec {
    /// The `kind` oneof; None when unset.
    pub kind: Option<OperationResponseSpecKind>,
}

/// OperationResult is the serialized result returned from an Execute call.
///
/// Native message type for `gestalt.provider.v1.OperationResult`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OperationResult {
    /// The `status` field.
    pub status: i32,
    /// The `body` field.
    pub body: Vec<u8>,
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, StringList>,
}

/// ProviderContext identifies the provider process that received the request
/// context from the host and is trusted to propagate it back to host services.
///
/// Native message type for `gestalt.provider.v1.ProviderContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProviderContext {
    /// The `kind` field.
    pub kind: String,
    /// The `name` field.
    pub name: String,
}

/// ProviderMetadata describes an integration provider's static capabilities.
///
/// Native message type for `gestalt.provider.v1.ProviderMetadata`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProviderMetadata {
    /// The `name` field.
    pub name: String,
    /// The `display_name` field.
    pub display_name: String,
    /// The `description` field.
    pub description: String,
    /// The `connection_mode` field.
    pub connection_mode: ConnectionMode,
    /// The `auth_types` field.
    pub auth_types: Vec<String>,
    /// The `connection_params` field.
    pub connection_params: std::collections::BTreeMap<String, ConnectionParamDef>,
    /// The `static_catalog` field; None when unset.
    pub static_catalog: Option<Catalog>,
    /// The `supports_session_catalog` field.
    pub supports_session_catalog: bool,
    /// The `min_protocol_version` field.
    pub min_protocol_version: i32,
    /// The `max_protocol_version` field.
    pub max_protocol_version: i32,
    /// Workflow definitions this app declares as desired state. Each entry is a
    /// serialized gestalt.provider.v1.WorkflowDefinitionSpec (workflow.proto).
    /// Framed as bytes because workflow.proto imports app.proto, so this file
    /// cannot reference WorkflowDefinitionSpec directly. The spec `id` is the
    /// app-local id; stored ids look like app_notes_daily-summary (app name + local id)
    /// and are applied with gestaltd authority on the config-definitions reconcile path.
    ///
    /// The `workflow_definition_specs` field.
    pub workflow_definition_specs: Vec<Vec<u8>>,
}

/// RequestContext bundles the caller, credential, access, and host metadata for
/// one operation.
///
/// Native message type for `gestalt.provider.v1.RequestContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RequestContext {
    /// The `subject` field; None when unset.
    pub subject: Option<SubjectContext>,
    /// The `credential` field; None when unset.
    pub credential: Option<CredentialContext>,
    /// The `access` field; None when unset.
    pub access: Option<AccessContext>,
    /// The `workflow` field; None when unset.
    pub workflow: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `host` field; None when unset.
    pub host: Option<HostContext>,
    /// Original agent caller when an agent tool executes with delegated run-as identity.
    ///
    /// The `agent_subject` field; None when unset.
    pub agent_subject: Option<SubjectContext>,
    /// The `caller` field; None when unset.
    pub caller: Option<ProviderContext>,
    /// The `invocation` field; None when unset.
    pub invocation: Option<InvocationContext>,
    /// Agent tool refs granted to the operation request, when the request is
    /// executing as an agent tool.
    ///
    /// The `tool_refs` field.
    pub tool_refs: Vec<AgentToolRef>,
    /// Preserves the distinction between an omitted tool-ref context and an
    /// explicitly empty inherited tool-ref context.
    ///
    /// The `tool_refs_set` field.
    pub tool_refs_set: bool,
    /// The `request_meta` field; None when unset.
    pub request_meta: Option<RequestMetaContext>,
    /// The `agent` field; None when unset.
    pub agent: Option<AgentInvocationContext>,
}

/// Native message type for `gestalt.provider.v1.RequestMetaContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RequestMetaContext {
    /// The `client_ip` field.
    pub client_ip: String,
    /// The `remote_addr` field.
    pub remote_addr: String,
    /// The `user_agent` field.
    pub user_agent: String,
}

/// ResolveHTTPSubjectRequest asks a provider to map a verified hosted HTTP
/// request to a concrete Gestalt subject before normal operation authorization
/// and dispatch.
///
/// Native message type for `gestalt.provider.v1.ResolveHTTPSubjectRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResolveHTTPSubjectRequest {
    /// The `request` field; None when unset.
    pub request: Option<HTTPSubjectRequest>,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// ResolveHTTPSubjectResponse returns the concrete Gestalt subject a hosted HTTP
/// request should execute as. An unset subject means "fall back to the binding
/// subject". When reject_status is set, the host should reject the inbound
/// request with the provided status and message.
///
/// Native message type for `gestalt.provider.v1.ResolveHTTPSubjectResponse`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResolveHTTPSubjectResponse {
    /// The `subject` field; None when unset.
    pub subject: Option<SubjectContext>,
    /// The `reject_status` field.
    pub reject_status: i32,
    /// The `reject_message` field.
    pub reject_message: String,
}

/// StartProviderRequest configures an integration provider for one runtime
/// session.
///
/// Native message type for `gestalt.provider.v1.StartProviderRequest`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StartProviderRequest {
    /// The `name` field.
    pub name: String,
    /// The `config` field; None when unset.
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `protocol_version` field.
    pub protocol_version: i32,
}

/// StartProviderResponse confirms the protocol version the provider is serving.
///
/// Native message type for `gestalt.provider.v1.StartProviderResponse`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StartProviderResponse {
    /// The `protocol_version` field.
    pub protocol_version: i32,
}

/// StreamResponseSpec describes a streaming operation response. The media type
/// names the representation (for example application/x-ndjson); the item schema
/// is optional and describes one yielded item when the stream is typed.
///
/// Native message type for `gestalt.provider.v1.StreamResponseSpec`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StreamResponseSpec {
    /// The `media_type` field.
    pub media_type: String,
    /// The `item_schema` field; None when unset.
    pub item_schema: Option<serde_json::Map<String, serde_json::Value>>,
}

/// StringList is a helper map value for repeated HTTP header and query values.
///
/// Native message type for `gestalt.provider.v1.StringList`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StringList {
    /// The `values` field.
    pub values: Vec<String>,
}

/// SubjectContext identifies the caller that initiated an operation.
///
/// Native message type for `gestalt.provider.v1.SubjectContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubjectContext {
    /// The `id` field.
    pub id: String,
    /// The `email` field.
    pub email: String,
    /// The `display_name` field.
    pub display_name: String,
    /// The `scopes` field.
    pub scopes: Vec<String>,
    /// The `permissions` field.
    pub permissions: Vec<SubjectPermissionContext>,
}

/// Native message type for `gestalt.provider.v1.SubjectPermissionContext`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubjectPermissionContext {
    /// The `app` field.
    pub app: String,
    /// The `operations` field.
    pub operations: Vec<String>,
    /// The `all_operations` field.
    pub all_operations: bool,
}

/// UnaryResponseSpec describes a unary (fully materialized) operation response.
///
/// Native message type for `gestalt.provider.v1.UnaryResponseSpec`.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UnaryResponseSpec {
    /// The `schema` field; None when unset.
    pub schema: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Client for the `gestalt.provider.v1.App` service.
pub struct App {
    inner: v1::app_client::AppClient<HostServiceChannel>,
    timeout: Option<std::time::Duration>,
    context: Option<RequestContext>,
}

impl App {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::app_client::AppClient::new(plain_channel(channel)),
            timeout: None,
            context: 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
    }

    /// Sets the default request context, injected into outgoing requests
    /// that do not carry one.
    pub fn with_context(mut self, context: RequestContext) -> Self {
        self.context = Some(context);
        self
    }

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

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

    /// Calls `gestalt.provider.v1.App.Invoke`.
    /// The result decodes with the standard JSON operation envelope
    /// semantics; payload failures surface as [`InvokeError`].
    pub async fn invoke(
        &mut self,
        app: String,
        operation: String,
        params: Option<serde_json::Map<String, serde_json::Value>>,
        options: AppInvokeOptions,
    ) -> Result<serde_json::Value, InvokeError> {
        let request = AppInvokeRequest {
            app,
            operation,
            params,
            connection: options.connection,
            instance: options.instance,
            idempotency_key: options.idempotency_key,
            credential_mode: options.credential_mode,
            run_as: options.run_as,
            headers: options.headers,
            context: self.context.clone(),
        };
        let invoke_context_app = request.app.clone();
        let invoke_context_operation = request.operation.clone();
        let mut tonic_request = tonic::Request::new(to_wire_app_invoke_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_operation_result(
            self.inner
                .invoke(tonic_request)
                .await
                .map_err(GestaltError::from)?
                .into_inner(),
        );
        Ok(decode_app_result(
            &invoke_context_app,
            &invoke_context_operation,
            response.status,
            &response.body,
        )?)
    }

    /// Calls `gestalt.provider.v1.App.Invoke` with the full request and response messages.
    pub async fn invoke_raw(
        &mut self,
        request: AppInvokeRequest,
    ) -> Result<OperationResult, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(to_wire_app_invoke_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.invoke(tonic_request).await?;
        Ok(from_wire_operation_result(response.into_inner()))
    }

    /// InvokeStream is the streaming counterpart of Invoke. It is gRPC-only (no
    /// REST binding) and shares Invoke's request shape, authorization, and
    /// signature policy. The first response frame is always InvokeMetadata;
    /// subsequent frames carry data bytes from the operation's stream response.
    /// A mid-stream error may emit a trailing metadata frame with an error status
    /// followed by a JSON error body, after which the stream ends.
    ///
    /// Calls `gestalt.provider.v1.App.InvokeStream`, returning a stream of converted frames.
    pub async fn invoke_stream(
        &mut self,
        request: AppInvokeRequest,
    ) -> Result<AppInvokeStreamStream, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let response = self
            .inner
            .invoke_stream(to_wire_app_invoke_request(request))
            .await?;
        Ok(AppInvokeStreamStream {
            inner: response.into_inner(),
        })
    }

    /// Calls `gestalt.provider.v1.App.InvokeGraphQL`.
    pub async fn invoke_graphql(
        &mut self,
        app: String,
        document: String,
        options: AppInvokeGraphQLOptions,
    ) -> Result<OperationResult, GestaltError> {
        let request = AppInvokeGraphQLRequest {
            app,
            document,
            connection: options.connection,
            instance: options.instance,
            idempotency_key: options.idempotency_key,
            variables: options.variables,
            headers: options.headers,
            context: self.context.clone(),
        };
        let mut tonic_request = tonic::Request::new(to_wire_app_invoke_graphql_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.invoke_graph_ql(tonic_request).await?;
        Ok(from_wire_operation_result(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.App.InvokeGraphQL` with the full request and response messages.
    pub async fn invoke_graphql_raw(
        &mut self,
        request: AppInvokeGraphQLRequest,
    ) -> Result<OperationResult, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(to_wire_app_invoke_graphql_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.invoke_graph_ql(tonic_request).await?;
        Ok(from_wire_operation_result(response.into_inner()))
    }
}

/// Optional parameters of [`App::invoke`]; the default value leaves every
/// option unset.
#[derive(Clone, Debug, Default)]
pub struct AppInvokeOptions {
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `credential_mode` field.
    pub credential_mode: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// headers overrides outbound static headers declared by the target provider.
    ///
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, String>,
}

/// Optional parameters of [`App::invoke_stream`]; the default value leaves every
/// option unset.
#[derive(Clone, Debug, Default)]
pub struct AppInvokeStreamOptions {
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `credential_mode` field.
    pub credential_mode: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// headers overrides outbound static headers declared by the target provider.
    ///
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, String>,
}

/// Optional parameters of [`App::invoke_graphql`]; the default value leaves every
/// option unset.
#[derive(Clone, Debug, Default)]
pub struct AppInvokeGraphQLOptions {
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `variables` field; None when unset.
    pub variables: Option<serde_json::Map<String, serde_json::Value>>,
    /// headers overrides outbound static headers declared by the target provider.
    ///
    /// The `headers` field.
    pub headers: std::collections::BTreeMap<String, String>,
}

/// InvokeStream is the streaming counterpart of Invoke. It is gRPC-only (no
/// REST binding) and shares Invoke's request shape, authorization, and
/// signature policy. The first response frame is always InvokeMetadata;
/// subsequent frames carry data bytes from the operation's stream response.
/// A mid-stream error may emit a trailing metadata frame with an error status
/// followed by a JSON error body, after which the stream ends.
///
/// Stream of converted `InvokeFrame` frames; transport errors convert to GestaltError.
pub struct AppInvokeStreamStream {
    inner: tonic::Streaming<v1::InvokeFrame>,
}

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

/// AppProvider models the shared Gestalt integration-provider protocol.
///
/// Client for the `gestalt.provider.v1.AppProvider` service.
pub struct AppProvider {
    inner: v1::app_provider_client::AppProviderClient<tonic::transport::Channel>,
    timeout: Option<std::time::Duration>,
    context: Option<RequestContext>,
}

impl AppProvider {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::app_provider_client::AppProviderClient::new(channel),
            timeout: None,
            context: 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
    }

    /// Sets the default request context, injected into outgoing requests
    /// that do not carry one.
    pub fn with_context(mut self, context: RequestContext) -> Self {
        self.context = Some(context);
        self
    }

    /// Calls `gestalt.provider.v1.AppProvider.GetMetadata`.
    pub async fn get_metadata(&mut self) -> Result<ProviderMetadata, GestaltError> {
        let mut tonic_request = tonic::Request::new(());
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_metadata(tonic_request).await?;
        Ok(from_wire_provider_metadata(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.AppProvider.StartProvider`.
    pub async fn start_provider(
        &mut self,
        name: String,
        protocol_version: i32,
        config: Option<serde_json::Map<String, serde_json::Value>>,
    ) -> Result<StartProviderResponse, GestaltError> {
        let request = StartProviderRequest {
            name,
            protocol_version,
            config,
        };
        let mut tonic_request = tonic::Request::new(to_wire_start_provider_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.start_provider(tonic_request).await?;
        Ok(from_wire_start_provider_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.AppProvider.StartProvider` with the full request and response messages.
    pub async fn start_provider_raw(
        &mut self,
        request: StartProviderRequest,
    ) -> Result<StartProviderResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_start_provider_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.start_provider(tonic_request).await?;
        Ok(from_wire_start_provider_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.AppProvider.Execute`.
    pub async fn execute(
        &mut self,
        operation: String,
        token: String,
        invocation_id: String,
        idempotency_key: String,
        params: Option<serde_json::Map<String, serde_json::Value>>,
    ) -> Result<OperationResult, GestaltError> {
        let request = ExecuteRequest {
            operation,
            token,
            invocation_id,
            idempotency_key,
            params,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(to_wire_execute_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.execute(tonic_request).await?;
        Ok(from_wire_operation_result(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.AppProvider.Execute` with the full request and response messages.
    pub async fn execute_raw(
        &mut self,
        request: ExecuteRequest,
    ) -> Result<OperationResult, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(to_wire_execute_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.execute(tonic_request).await?;
        Ok(from_wire_operation_result(response.into_inner()))
    }

    /// ExecuteStream is the streaming counterpart of Execute. The first response
    /// frame is always InvokeMetadata; subsequent frames carry encoded data bytes.
    /// A mid-stream error may emit a trailing metadata frame with an error status
    /// followed by a JSON error body, after which the stream ends.
    ///
    /// Calls `gestalt.provider.v1.AppProvider.ExecuteStream`, returning a stream of converted frames.
    pub async fn execute_stream(
        &mut self,
        request: ExecuteRequest,
    ) -> Result<AppProviderExecuteStreamStream, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let response = self
            .inner
            .execute_stream(to_wire_execute_request(request))
            .await?;
        Ok(AppProviderExecuteStreamStream {
            inner: response.into_inner(),
        })
    }

    /// Calls `gestalt.provider.v1.AppProvider.ResolveHTTPSubject`.
    pub async fn resolve_http_subject(
        &mut self,
        request: ResolveHTTPSubjectRequest,
    ) -> Result<ResolveHTTPSubjectResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(to_wire_resolve_http_subject_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.resolve_http_subject(tonic_request).await?;
        Ok(from_wire_resolve_http_subject_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.AppProvider.GetSessionCatalog`.
    pub async fn get_session_catalog(
        &mut self,
        token: String,
        invocation_id: String,
    ) -> Result<GetSessionCatalogResponse, GestaltError> {
        let request = GetSessionCatalogRequest {
            token,
            invocation_id,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(to_wire_get_session_catalog_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_session_catalog(tonic_request).await?;
        Ok(from_wire_get_session_catalog_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.AppProvider.GetSessionCatalog` with the full request and response messages.
    pub async fn get_session_catalog_raw(
        &mut self,
        request: GetSessionCatalogRequest,
    ) -> Result<GetSessionCatalogResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(to_wire_get_session_catalog_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_session_catalog(tonic_request).await?;
        Ok(from_wire_get_session_catalog_response(
            response.into_inner(),
        ))
    }
}

/// ExecuteStream is the streaming counterpart of Execute. The first response
/// frame is always InvokeMetadata; subsequent frames carry encoded data bytes.
/// A mid-stream error may emit a trailing metadata frame with an error status
/// followed by a JSON error body, after which the stream ends.
///
/// Stream of converted `InvokeFrame` frames; transport errors convert to GestaltError.
pub struct AppProviderExecuteStreamStream {
    inner: tonic::Streaming<v1::InvokeFrame>,
}

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