gestalt-sdk 0.0.1-alpha.19

// Code generated by sdkgen. DO NOT EDIT.

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

use crate::agent::AgentOutput;
use crate::app::{AgentToolRef, RequestContext, SubjectContext};
use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
use crate::codec::workflow::{
    from_wire_get_workflow_provider_run_events_response,
    from_wire_get_workflow_provider_run_output_response,
    from_wire_list_workflow_provider_definitions_response,
    from_wire_list_workflow_provider_runs_response, from_wire_signal_workflow_run_response,
    from_wire_workflow_definition, from_wire_workflow_event, from_wire_workflow_run,
    to_wire_apply_workflow_provider_definition_request,
    to_wire_cancel_workflow_provider_run_request,
    to_wire_delete_workflow_provider_definition_request,
    to_wire_deliver_workflow_provider_event_request,
    to_wire_get_workflow_provider_definition_request,
    to_wire_get_workflow_provider_run_events_request,
    to_wire_get_workflow_provider_run_output_request, to_wire_get_workflow_provider_run_request,
    to_wire_list_workflow_provider_definitions_request,
    to_wire_list_workflow_provider_runs_request,
    to_wire_set_workflow_provider_activation_paused_request,
    to_wire_set_workflow_provider_definition_paused_request,
    to_wire_signal_or_start_workflow_provider_run_request,
    to_wire_signal_workflow_provider_run_request, to_wire_start_workflow_provider_run_request,
};
use crate::generated::v1;
use crate::rpc_support::GestaltError;

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

/// Named values of `WorkflowRunStatus`.
pub mod workflow_run_status {
    /// WORKFLOW_RUN_STATUS_UNSPECIFIED.
    pub const WORKFLOW_RUN_STATUS_UNSPECIFIED: i32 = 0;
    /// WORKFLOW_RUN_STATUS_PENDING.
    pub const WORKFLOW_RUN_STATUS_PENDING: i32 = 1;
    /// WORKFLOW_RUN_STATUS_RUNNING.
    pub const WORKFLOW_RUN_STATUS_RUNNING: i32 = 2;
    /// WORKFLOW_RUN_STATUS_SUCCEEDED.
    pub const WORKFLOW_RUN_STATUS_SUCCEEDED: i32 = 3;
    /// WORKFLOW_RUN_STATUS_FAILED.
    pub const WORKFLOW_RUN_STATUS_FAILED: i32 = 4;
    /// WORKFLOW_RUN_STATUS_CANCELED.
    pub const WORKFLOW_RUN_STATUS_CANCELED: i32 = 5;
}

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

/// Named values of `WorkflowStepStatus`.
pub mod workflow_step_status {
    /// WORKFLOW_STEP_STATUS_UNSPECIFIED.
    pub const WORKFLOW_STEP_STATUS_UNSPECIFIED: i32 = 0;
    /// WORKFLOW_STEP_STATUS_PENDING.
    pub const WORKFLOW_STEP_STATUS_PENDING: i32 = 1;
    /// WORKFLOW_STEP_STATUS_RUNNING.
    pub const WORKFLOW_STEP_STATUS_RUNNING: i32 = 2;
    /// WORKFLOW_STEP_STATUS_SKIPPED.
    pub const WORKFLOW_STEP_STATUS_SKIPPED: i32 = 3;
    /// WORKFLOW_STEP_STATUS_SUCCEEDED.
    pub const WORKFLOW_STEP_STATUS_SUCCEEDED: i32 = 4;
    /// WORKFLOW_STEP_STATUS_FAILED.
    pub const WORKFLOW_STEP_STATUS_FAILED: i32 = 5;
    /// WORKFLOW_STEP_STATUS_UNKNOWN.
    pub const WORKFLOW_STEP_STATUS_UNKNOWN: i32 = 6;
}

/// Native message type for `gestalt.provider.v1.ApplyWorkflowProviderDefinitionRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ApplyWorkflowProviderDefinitionRequest {
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `spec` field; None when unset.
    pub spec: Option<WorkflowDefinitionSpec>,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `requested_by_subject_id` field.
    pub requested_by_subject_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

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

/// Native message type for `gestalt.provider.v1.CancelWorkflowProviderRunRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CancelWorkflowProviderRunRequest {
    /// The `run_id` field.
    pub run_id: String,
    /// The `reason` field.
    pub reason: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.DeleteWorkflowProviderDefinitionRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteWorkflowProviderDefinitionRequest {
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.DeliverWorkflowProviderEventRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeliverWorkflowProviderEventRequest {
    /// The `app_name` field.
    pub app_name: String,
    /// The `event` field; None when unset.
    pub event: Option<WorkflowEvent>,
    /// The `delivered_by_subject_id` field.
    pub delivered_by_subject_id: String,
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.GetWorkflowProviderDefinitionRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetWorkflowProviderDefinitionRequest {
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.GetWorkflowProviderRunEventsRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetWorkflowProviderRunEventsRequest {
    /// The `run_id` field.
    pub run_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

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

/// Native message type for `gestalt.provider.v1.GetWorkflowProviderRunOutputRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetWorkflowProviderRunOutputRequest {
    /// The `run_id` field.
    pub run_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.GetWorkflowProviderRunOutputResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetWorkflowProviderRunOutputResponse {
    /// The `output` field; None when unset.
    pub output: Option<serde_json::Value>,
}

/// Native message type for `gestalt.provider.v1.GetWorkflowProviderRunRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetWorkflowProviderRunRequest {
    /// The `run_id` field.
    pub run_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

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

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

/// Native message type for `gestalt.provider.v1.ListWorkflowProviderRunsRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListWorkflowProviderRunsRequest {
    /// The `page_size` field.
    pub page_size: i32,
    /// The `page_token` field.
    pub page_token: String,
    /// The `status` field.
    pub status: WorkflowRunStatus,
    /// The `target_app` field.
    pub target_app: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.ListWorkflowProviderRunsResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListWorkflowProviderRunsResponse {
    /// The `runs` field.
    pub runs: Vec<WorkflowRun>,
    /// The `next_page_token` field.
    pub next_page_token: String,
}

/// Native message type for `gestalt.provider.v1.SetWorkflowProviderActivationPausedRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetWorkflowProviderActivationPausedRequest {
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `activation_id` field.
    pub activation_id: String,
    /// The `paused` field.
    pub paused: bool,
    /// The `requested_by_subject_id` field.
    pub requested_by_subject_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.SetWorkflowProviderDefinitionPausedRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetWorkflowProviderDefinitionPausedRequest {
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `paused` field.
    pub paused: bool,
    /// The `requested_by_subject_id` field.
    pub requested_by_subject_id: String,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.SignalOrStartWorkflowProviderRunRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SignalOrStartWorkflowProviderRunRequest {
    /// The `workflow_key` field.
    pub workflow_key: String,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `created_by_subject_id` field.
    pub created_by_subject_id: String,
    /// The `signal` field; None when unset.
    pub signal: Option<WorkflowSignal>,
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// The `input` field; None when unset.
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `expected_definition_generation` field.
    pub expected_definition_generation: i64,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.SignalWorkflowProviderRunRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SignalWorkflowProviderRunRequest {
    /// The `run_id` field.
    pub run_id: String,
    /// The `signal` field; None when unset.
    pub signal: Option<WorkflowSignal>,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Native message type for `gestalt.provider.v1.SignalWorkflowRunResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SignalWorkflowRunResponse {
    /// The `run` field; None when unset.
    pub run: Option<WorkflowRun>,
    /// The `signal` field; None when unset.
    pub signal: Option<WorkflowSignal>,
    /// The `started_run` field.
    pub started_run: bool,
    /// The `workflow_key` field.
    pub workflow_key: String,
}

/// Native message type for `gestalt.provider.v1.StartWorkflowProviderRunRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StartWorkflowProviderRunRequest {
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `created_by_subject_id` field.
    pub created_by_subject_id: String,
    /// The `workflow_key` field.
    pub workflow_key: String,
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// The `input` field; None when unset.
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `expected_definition_generation` field.
    pub expected_definition_generation: i64,
    /// The `context` field; None when unset.
    pub context: Option<RequestContext>,
}

/// Values of the `trigger` oneof in `WorkflowActivation`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum WorkflowActivationTrigger {
    /// The `schedule` variant.
    Schedule(WorkflowScheduleActivation),
    /// The `event` variant.
    Event(WorkflowEventActivation),
}

/// Native message type for `gestalt.provider.v1.WorkflowActivation`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowActivation {
    /// The `id` field.
    pub id: String,
    /// The `input` field; None when unset.
    pub input: Option<WorkflowValue>,
    /// The `paused` field.
    pub paused: bool,
    /// The `trigger` oneof; None when unset.
    pub trigger: Option<WorkflowActivationTrigger>,
}

/// Native message type for `gestalt.provider.v1.WorkflowAgentMessage`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowAgentMessage {
    /// The `role` field.
    pub role: String,
    /// The `text` field; None when unset.
    pub text: Option<WorkflowText>,
    /// The `metadata` field; None when unset.
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

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

/// Native message type for `gestalt.provider.v1.WorkflowDefinition`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowDefinition {
    /// The `id` field.
    pub id: String,
    /// The `generation` field.
    pub generation: i64,
    /// The `target` field; None when unset.
    pub target: Option<BoundWorkflowTarget>,
    /// The `activations` field.
    pub activations: Vec<WorkflowActivation>,
    /// The `paused` field.
    pub paused: bool,
    /// The `created_by_subject_id` field.
    pub created_by_subject_id: String,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
    /// The `updated_at` field; None when unset.
    pub updated_at: Option<std::time::SystemTime>,
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
}

/// Native message type for `gestalt.provider.v1.WorkflowDefinitionSpec`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowDefinitionSpec {
    /// The `id` field.
    pub id: String,
    /// The `target` field; None when unset.
    pub target: Option<BoundWorkflowTarget>,
    /// The `activations` field.
    pub activations: Vec<WorkflowActivation>,
    /// The `paused` field.
    pub paused: bool,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
}

/// Native message type for `gestalt.provider.v1.WorkflowEvent`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowEvent {
    /// The `id` field.
    pub id: String,
    /// The `source` field.
    pub source: String,
    /// The `spec_version` field.
    pub spec_version: String,
    /// The `type` field.
    pub r#type: String,
    /// The `subject` field.
    pub subject: String,
    /// The `time` field; None when unset.
    pub time: Option<std::time::SystemTime>,
    /// The `datacontenttype` field.
    pub datacontenttype: String,
    /// The `data` field; None when unset.
    pub data: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `extensions` field.
    pub extensions: std::collections::BTreeMap<String, serde_json::Value>,
}

/// Native message type for `gestalt.provider.v1.WorkflowEventActivation`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowEventActivation {
    /// The `match` field; None when unset.
    pub r#match: Option<WorkflowEventMatch>,
}

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

/// Native message type for `gestalt.provider.v1.WorkflowEventTriggerInvocation`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowEventTriggerInvocation {
    /// The `activation_id` field.
    pub activation_id: String,
    /// The `event` field; None when unset.
    pub event: Option<WorkflowEvent>,
}

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

/// Native message type for `gestalt.provider.v1.WorkflowObject`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowObject {
    /// The `fields` field.
    pub fields: std::collections::BTreeMap<String, WorkflowValue>,
}

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

/// Native message type for `gestalt.provider.v1.WorkflowRun`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowRun {
    /// The `id` field.
    pub id: String,
    /// The `status` field.
    pub status: WorkflowRunStatus,
    /// The `target` field; None when unset.
    pub target: Option<BoundWorkflowTarget>,
    /// The `trigger` field; None when unset.
    pub trigger: Option<WorkflowRunTrigger>,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
    /// The `started_at` field; None when unset.
    pub started_at: Option<std::time::SystemTime>,
    /// The `completed_at` field; None when unset.
    pub completed_at: Option<std::time::SystemTime>,
    /// The `status_message` field.
    pub status_message: String,
    /// The `output` field; None when unset.
    pub output: Option<serde_json::Value>,
    /// The `created_by_subject_id` field.
    pub created_by_subject_id: String,
    /// The `workflow_key` field.
    pub workflow_key: String,
    /// The `provider_name` field.
    pub provider_name: String,
    /// The `definition_id` field.
    pub definition_id: String,
    /// The `run_as` field; None when unset.
    pub run_as: Option<SubjectContext>,
    /// The `input` field; None when unset.
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `definition_generation` field.
    pub definition_generation: i64,
    /// The `current_step_id` field.
    pub current_step_id: String,
    /// The `steps` field.
    pub steps: Vec<WorkflowStepExecution>,
}

/// Native message type for `gestalt.provider.v1.WorkflowRunEvent`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowRunEvent {
    /// The `id` field.
    pub id: String,
    /// The `run_id` field.
    pub run_id: String,
    /// The `step_id` field.
    pub step_id: String,
    /// The `type` field.
    pub r#type: String,
    /// The `data` field; None when unset.
    pub data: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
}

/// Values of the `kind` oneof in `WorkflowRunTrigger`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum WorkflowRunTriggerKind {
    /// The `manual` variant.
    Manual(WorkflowManualTrigger),
    /// The `schedule` variant.
    Schedule(WorkflowScheduleTrigger),
    /// The `event` variant.
    Event(WorkflowEventTriggerInvocation),
}

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

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

/// Native message type for `gestalt.provider.v1.WorkflowScheduleTrigger`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowScheduleTrigger {
    /// The `activation_id` field.
    pub activation_id: String,
    /// The `scheduled_for` field; None when unset.
    pub scheduled_for: Option<std::time::SystemTime>,
}

/// Native message type for `gestalt.provider.v1.WorkflowSignal`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowSignal {
    /// The `id` field.
    pub id: String,
    /// The `name` field.
    pub name: String,
    /// The `payload` field; None when unset.
    pub payload: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `metadata` field; None when unset.
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `created_by_subject_id` field.
    pub created_by_subject_id: String,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `sequence` field.
    pub sequence: i64,
}

/// Values of the `action` oneof in `WorkflowStep`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum WorkflowStepAction {
    /// The `app` variant.
    App(WorkflowStepAppCall),
    /// The `agent` variant.
    Agent(WorkflowStepAgentTurn),
}

/// Native message type for `gestalt.provider.v1.WorkflowStep`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStep {
    /// The `id` field.
    pub id: String,
    /// The `inputs` field.
    pub inputs: std::collections::BTreeMap<String, WorkflowValue>,
    /// The `when` field; None when unset.
    pub when: Option<WorkflowStepWhen>,
    /// The `timeout_seconds` field.
    pub timeout_seconds: i32,
    /// The `metadata` field; None when unset.
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `action` oneof; None when unset.
    pub action: Option<WorkflowStepAction>,
}

/// Native message type for `gestalt.provider.v1.WorkflowStepAgentTurn`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStepAgentTurn {
    /// The `provider` field.
    pub provider: String,
    /// The `model` field.
    pub model: String,
    /// The `session_key` field.
    pub session_key: String,
    /// The `prompt` field; None when unset.
    pub prompt: Option<WorkflowText>,
    /// The `messages` field.
    pub messages: Vec<WorkflowAgentMessage>,
    /// The `tools` field.
    pub tools: Vec<AgentToolRef>,
    /// The `output` field; None when unset.
    pub output: Option<AgentOutput>,
    /// The `model_options` field; None when unset.
    pub model_options: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Native message type for `gestalt.provider.v1.WorkflowStepAppCall`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStepAppCall {
    /// The `name` field.
    pub name: String,
    /// The `operation` field.
    pub operation: String,
    /// The `input` field; None when unset.
    pub input: Option<WorkflowValue>,
    /// The `connection` field.
    pub connection: String,
    /// The `instance` field.
    pub instance: String,
    /// The `credential_mode` field.
    pub credential_mode: String,
}

/// Native message type for `gestalt.provider.v1.WorkflowStepAttempt`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStepAttempt {
    /// The `id` field.
    pub id: String,
    /// The `status` field.
    pub status: WorkflowStepStatus,
    /// The `idempotency_key` field.
    pub idempotency_key: String,
    /// The `input` field; None when unset.
    pub input: Option<serde_json::Value>,
    /// The `output` field; None when unset.
    pub output: Option<serde_json::Value>,
    /// The `status_message` field.
    pub status_message: String,
    /// The `started_at` field; None when unset.
    pub started_at: Option<std::time::SystemTime>,
    /// The `completed_at` field; None when unset.
    pub completed_at: Option<std::time::SystemTime>,
}

/// Native message type for `gestalt.provider.v1.WorkflowStepExecution`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStepExecution {
    /// The `step_id` field.
    pub step_id: String,
    /// The `status` field.
    pub status: WorkflowStepStatus,
    /// The `attempts` field.
    pub attempts: Vec<WorkflowStepAttempt>,
    /// The `input` field; None when unset.
    pub input: Option<serde_json::Value>,
    /// The `output` field; None when unset.
    pub output: Option<serde_json::Value>,
    /// The `status_message` field.
    pub status_message: String,
    /// The `skip_reason` field.
    pub skip_reason: String,
    /// The `started_at` field; None when unset.
    pub started_at: Option<std::time::SystemTime>,
    /// The `completed_at` field; None when unset.
    pub completed_at: Option<std::time::SystemTime>,
}

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

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

/// Native message type for `gestalt.provider.v1.WorkflowStepWhen`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WorkflowStepWhen {
    /// The `value` field; None when unset.
    pub value: Option<WorkflowValue>,
    /// The `equals` field; None when unset.
    pub equals: Option<serde_json::Value>,
}

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

/// Values of the `kind` oneof in `WorkflowValue`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum WorkflowValueKind {
    /// The `literal` variant.
    Literal(serde_json::Value),
    /// The `object` variant.
    Object(WorkflowObject),
    /// The `array` variant.
    Array(WorkflowArray),
    /// The `template` variant.
    Template(WorkflowText),
    /// The `input` variant.
    Input(WorkflowPathSource),
    /// The `signal` variant.
    Signal(WorkflowPathSource),
    /// The `step_output` variant.
    StepOutput(WorkflowStepOutputSource),
    /// The `step_input` variant.
    StepInput(WorkflowStepInputSource),
}

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

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

impl Workflow {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::workflow_client::WorkflowClient::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 `workflow` host service described by the environment.
    pub async fn connect() -> Result<Self, GestaltError> {
        Self::connect_named("").await
    }

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

    /// Calls `gestalt.provider.v1.Workflow.ApplyDefinition`.
    pub async fn apply_definition(
        &mut self,
        provider_name: String,
        idempotency_key: String,
        spec: Option<WorkflowDefinitionSpec>,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let request = ApplyWorkflowProviderDefinitionRequest {
            provider_name,
            idempotency_key,
            spec,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_apply_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.apply_definition(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.ApplyDefinition` with the full request and response messages.
    pub async fn apply_definition_raw(
        &mut self,
        request: ApplyWorkflowProviderDefinitionRequest,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_apply_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.apply_definition(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetDefinition`.
    pub async fn get_definition(
        &mut self,
        definition_id: String,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let request = GetWorkflowProviderDefinitionRequest {
            definition_id,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_get_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_definition(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetDefinition` with the full request and response messages.
    pub async fn get_definition_raw(
        &mut self,
        request: GetWorkflowProviderDefinitionRequest,
    ) -> Result<WorkflowDefinition, 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_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_definition(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.ListDefinitions`.
    pub async fn list_definitions(
        &mut self,
        request: ListWorkflowProviderDefinitionsRequest,
    ) -> Result<Vec<WorkflowDefinition>, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_list_workflow_provider_definitions_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_list_workflow_provider_definitions_response(
            self.inner
                .list_definitions(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.definitions)
    }

    /// Calls `gestalt.provider.v1.Workflow.ListDefinitions` with the full request and response messages.
    pub async fn list_definitions_raw(
        &mut self,
        request: ListWorkflowProviderDefinitionsRequest,
    ) -> Result<ListWorkflowProviderDefinitionsResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_list_workflow_provider_definitions_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_definitions(tonic_request).await?;
        Ok(from_wire_list_workflow_provider_definitions_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.SetDefinitionPaused`.
    pub async fn set_definition_paused(
        &mut self,
        definition_id: String,
        paused: bool,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let request = SetWorkflowProviderDefinitionPausedRequest {
            definition_id,
            paused,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(
            to_wire_set_workflow_provider_definition_paused_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_definition_paused(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.SetDefinitionPaused` with the full request and response messages.
    pub async fn set_definition_paused_raw(
        &mut self,
        request: SetWorkflowProviderDefinitionPausedRequest,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(
            to_wire_set_workflow_provider_definition_paused_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_definition_paused(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.SetActivationPaused`.
    pub async fn set_activation_paused(
        &mut self,
        definition_id: String,
        activation_id: String,
        paused: bool,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let request = SetWorkflowProviderActivationPausedRequest {
            definition_id,
            activation_id,
            paused,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(
            to_wire_set_workflow_provider_activation_paused_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_activation_paused(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.SetActivationPaused` with the full request and response messages.
    pub async fn set_activation_paused_raw(
        &mut self,
        request: SetWorkflowProviderActivationPausedRequest,
    ) -> Result<WorkflowDefinition, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(
            to_wire_set_workflow_provider_activation_paused_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_activation_paused(tonic_request).await?;
        Ok(from_wire_workflow_definition(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.DeleteDefinition`.
    pub async fn delete_definition(&mut self, definition_id: String) -> Result<(), GestaltError> {
        let request = DeleteWorkflowProviderDefinitionRequest {
            definition_id,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_delete_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_definition(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.Workflow.DeleteDefinition` with the full request and response messages.
    pub async fn delete_definition_raw(
        &mut self,
        request: DeleteWorkflowProviderDefinitionRequest,
    ) -> Result<(), GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_delete_workflow_provider_definition_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        self.inner.delete_definition(tonic_request).await?;
        Ok(())
    }

    /// Calls `gestalt.provider.v1.Workflow.StartRun`.
    #[allow(clippy::too_many_arguments)]
    pub async fn start_run(
        &mut self,
        idempotency_key: String,
        workflow_key: String,
        provider_name: String,
        definition_id: String,
        expected_definition_generation: i64,
        run_as: Option<SubjectContext>,
        input: Option<serde_json::Map<String, serde_json::Value>>,
    ) -> Result<WorkflowRun, GestaltError> {
        let request = StartWorkflowProviderRunRequest {
            idempotency_key,
            workflow_key,
            provider_name,
            definition_id,
            expected_definition_generation,
            run_as,
            input,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_start_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.start_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.StartRun` with the full request and response messages.
    pub async fn start_run_raw(
        &mut self,
        request: StartWorkflowProviderRunRequest,
    ) -> Result<WorkflowRun, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_start_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.start_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.ListRuns`.
    pub async fn list_runs(
        &mut self,
        page_size: i32,
        page_token: String,
        status: WorkflowRunStatus,
        target_app: String,
    ) -> Result<ListWorkflowProviderRunsResponse, GestaltError> {
        let request = ListWorkflowProviderRunsRequest {
            page_size,
            page_token,
            status,
            target_app,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_list_workflow_provider_runs_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_runs(tonic_request).await?;
        Ok(from_wire_list_workflow_provider_runs_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.ListRuns` with the full request and response messages.
    pub async fn list_runs_raw(
        &mut self,
        request: ListWorkflowProviderRunsRequest,
    ) -> Result<ListWorkflowProviderRunsResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_list_workflow_provider_runs_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_runs(tonic_request).await?;
        Ok(from_wire_list_workflow_provider_runs_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRun`.
    pub async fn get_run(&mut self, run_id: String) -> Result<WorkflowRun, GestaltError> {
        let request = GetWorkflowProviderRunRequest {
            run_id,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_get_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRun` with the full request and response messages.
    pub async fn get_run_raw(
        &mut self,
        request: GetWorkflowProviderRunRequest,
    ) -> Result<WorkflowRun, 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_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRunEvents`.
    pub async fn get_run_events(
        &mut self,
        run_id: String,
    ) -> Result<Vec<WorkflowRunEvent>, GestaltError> {
        let request = GetWorkflowProviderRunEventsRequest {
            run_id,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_get_workflow_provider_run_events_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_get_workflow_provider_run_events_response(
            self.inner.get_run_events(tonic_request).await?.into_inner(),
        );
        Ok(response.events)
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRunEvents` with the full request and response messages.
    pub async fn get_run_events_raw(
        &mut self,
        request: GetWorkflowProviderRunEventsRequest,
    ) -> Result<GetWorkflowProviderRunEventsResponse, 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_workflow_provider_run_events_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_run_events(tonic_request).await?;
        Ok(from_wire_get_workflow_provider_run_events_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRunOutput`.
    pub async fn get_run_output(
        &mut self,
        run_id: String,
    ) -> Result<Option<serde_json::Value>, GestaltError> {
        let request = GetWorkflowProviderRunOutputRequest {
            run_id,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_get_workflow_provider_run_output_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_get_workflow_provider_run_output_response(
            self.inner.get_run_output(tonic_request).await?.into_inner(),
        );
        Ok(response.output)
    }

    /// Calls `gestalt.provider.v1.Workflow.GetRunOutput` with the full request and response messages.
    pub async fn get_run_output_raw(
        &mut self,
        request: GetWorkflowProviderRunOutputRequest,
    ) -> Result<GetWorkflowProviderRunOutputResponse, 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_workflow_provider_run_output_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_run_output(tonic_request).await?;
        Ok(from_wire_get_workflow_provider_run_output_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.CancelRun`.
    pub async fn cancel_run(
        &mut self,
        run_id: String,
        reason: String,
    ) -> Result<WorkflowRun, GestaltError> {
        let request = CancelWorkflowProviderRunRequest {
            run_id,
            reason,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_cancel_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.cancel_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.CancelRun` with the full request and response messages.
    pub async fn cancel_run_raw(
        &mut self,
        request: CancelWorkflowProviderRunRequest,
    ) -> Result<WorkflowRun, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_cancel_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.cancel_run(tonic_request).await?;
        Ok(from_wire_workflow_run(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.SignalRun`.
    pub async fn signal_run(
        &mut self,
        run_id: String,
        signal: Option<WorkflowSignal>,
    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
        let request = SignalWorkflowProviderRunRequest {
            run_id,
            signal,
            context: self.context.clone(),
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_signal_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.signal_run(tonic_request).await?;
        Ok(from_wire_signal_workflow_run_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.SignalRun` with the full request and response messages.
    pub async fn signal_run_raw(
        &mut self,
        request: SignalWorkflowProviderRunRequest,
    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_signal_workflow_provider_run_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.signal_run(tonic_request).await?;
        Ok(from_wire_signal_workflow_run_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.SignalOrStartRun`.
    #[allow(clippy::too_many_arguments)]
    pub async fn signal_or_start_run(
        &mut self,
        workflow_key: String,
        idempotency_key: String,
        provider_name: String,
        definition_id: String,
        expected_definition_generation: i64,
        signal: Option<WorkflowSignal>,
        run_as: Option<SubjectContext>,
        input: Option<serde_json::Map<String, serde_json::Value>>,
    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
        let request = SignalOrStartWorkflowProviderRunRequest {
            workflow_key,
            idempotency_key,
            provider_name,
            definition_id,
            expected_definition_generation,
            signal,
            run_as,
            input,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(
            to_wire_signal_or_start_workflow_provider_run_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.signal_or_start_run(tonic_request).await?;
        Ok(from_wire_signal_workflow_run_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.SignalOrStartRun` with the full request and response messages.
    pub async fn signal_or_start_run_raw(
        &mut self,
        request: SignalOrStartWorkflowProviderRunRequest,
    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request = tonic::Request::new(
            to_wire_signal_or_start_workflow_provider_run_request(request),
        );
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.signal_or_start_run(tonic_request).await?;
        Ok(from_wire_signal_workflow_run_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Workflow.DeliverEvent`.
    pub async fn deliver_event(
        &mut self,
        event: Option<WorkflowEvent>,
        options: WorkflowDeliverEventOptions,
    ) -> Result<WorkflowEvent, GestaltError> {
        let request = DeliverWorkflowProviderEventRequest {
            event,
            app_name: options.app_name,
            provider_name: options.provider_name,
            context: self.context.clone(),
            ..Default::default()
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_deliver_workflow_provider_event_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.deliver_event(tonic_request).await?;
        Ok(from_wire_workflow_event(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Workflow.DeliverEvent` with the full request and response messages.
    pub async fn deliver_event_raw(
        &mut self,
        request: DeliverWorkflowProviderEventRequest,
    ) -> Result<WorkflowEvent, GestaltError> {
        let mut request = request;
        if request.context.is_none() {
            request.context = self.context.clone();
        }
        let mut tonic_request =
            tonic::Request::new(to_wire_deliver_workflow_provider_event_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.deliver_event(tonic_request).await?;
        Ok(from_wire_workflow_event(response.into_inner()))
    }
}

/// Optional parameters of [`Workflow::deliver_event`]; the default value leaves every
/// option unset.
#[derive(Clone, Debug, Default)]
pub struct WorkflowDeliverEventOptions {
    /// The `app_name` field.
    pub app_name: String,
    /// The `provider_name` field.
    pub provider_name: String,
}