gestalt-sdk 0.0.1-alpha.26

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for workflow.proto.

#![allow(clippy::all, unused_variables, unused_mut, dead_code)]

use crate::codec::support::to_wire_struct;
use crate::codec::workflow::{to_wire_workflow_definition_spec, to_wire_workflow_signal};
use crate::generated::v1;
use crate::public::generated::codec::agent::{
    decode_wire_agent_output_json, encode_wire_agent_output_json,
};
use crate::public::generated::codec::app::{
    decode_wire_agent_tool_ref_json, decode_wire_request_context_json,
    encode_wire_agent_tool_ref_json, encode_wire_request_context_json,
};
use crate::public::generated::workflow::{
    ApplyWorkflowProviderDefinitionRequest, CancelWorkflowProviderRunRequest,
    DeleteWorkflowProviderDefinitionRequest, GetWorkflowProviderDefinitionRequest,
    GetWorkflowProviderRunEventsRequest, GetWorkflowProviderRunOutputRequest,
    GetWorkflowProviderRunRequest, ListWorkflowProviderDefinitionsRequest,
    ListWorkflowProviderRunsRequest, SetWorkflowProviderActivationPausedRequest,
    SetWorkflowProviderDefinitionPausedRequest, SignalOrStartWorkflowProviderRunRequest,
    SignalWorkflowProviderRunRequest, StartWorkflowProviderRunRequest,
};

/// Converts a native `ApplyWorkflowProviderDefinitionRequest` to its wire message.
pub(crate) fn to_wire_apply_workflow_provider_definition_request(
    value: ApplyWorkflowProviderDefinitionRequest,
) -> v1::ApplyWorkflowProviderDefinitionRequest {
    v1::ApplyWorkflowProviderDefinitionRequest {
        provider: value.provider,
        spec: value.spec.map(to_wire_workflow_definition_spec),
        idempotency_key: value.idempotency_key,
        context: None,
        ..Default::default()
    }
}

/// Encodes a wire `WorkflowObject` as protobuf JSON.
pub(crate) fn encode_wire_workflow_object_json(value: &v1::WorkflowObject) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.fields.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.fields {
            map.insert(key.clone(), encode_wire_workflow_value_json(value));
        }
        object.insert("fields".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowObject`.
pub(crate) fn decode_wire_workflow_object_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowObject, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowObject {
        fields: match object.get("fields") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        decode_wire_workflow_value_json(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowArray` as protobuf JSON.
pub(crate) fn encode_wire_workflow_array_json(value: &v1::WorkflowArray) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.values.is_empty() {
        object.insert(
            "values".into(),
            serde_json::Value::Array(
                value
                    .values
                    .iter()
                    .map(|item| encode_wire_workflow_value_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowArray`.
pub(crate) fn decode_wire_workflow_array_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowArray, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowArray {
        values: match object.get("values") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for values")
                })?
                .iter()
                .map(|item| decode_wire_workflow_value_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowText` as protobuf JSON.
pub(crate) fn encode_wire_workflow_text_json(value: &v1::WorkflowText) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.template.is_empty() {
        object.insert(
            "template".into(),
            serde_json::Value::String(value.template.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowText`.
pub(crate) fn decode_wire_workflow_text_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowText, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowText {
        template: match object.get("template") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowPathSource` as protobuf JSON.
pub(crate) fn encode_wire_workflow_path_source_json(
    value: &v1::WorkflowPathSource,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.path.is_empty() {
        object.insert(
            "path".into(),
            serde_json::Value::String(value.path.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowPathSource`.
pub(crate) fn decode_wire_workflow_path_source_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowPathSource, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowPathSource {
        path: match object.get("path") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepOutputSource` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_output_source_json(
    value: &v1::WorkflowStepOutputSource,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.step_id.is_empty() {
        object.insert(
            "stepId".into(),
            serde_json::Value::String(value.step_id.to_string()),
        );
    }
    if !value.path.is_empty() {
        object.insert(
            "path".into(),
            serde_json::Value::String(value.path.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepOutputSource`.
pub(crate) fn decode_wire_workflow_step_output_source_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepOutputSource, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepOutputSource {
        step_id: match object.get("stepId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        path: match object.get("path") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepInputSource` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_input_source_json(
    value: &v1::WorkflowStepInputSource,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.step_id.is_empty() {
        object.insert(
            "stepId".into(),
            serde_json::Value::String(value.step_id.to_string()),
        );
    }
    if !value.path.is_empty() {
        object.insert(
            "path".into(),
            serde_json::Value::String(value.path.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepInputSource`.
pub(crate) fn decode_wire_workflow_step_input_source_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepInputSource, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepInputSource {
        step_id: match object.get("stepId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        path: match object.get("path") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowValue` as protobuf JSON.
pub(crate) fn encode_wire_workflow_value_json(value: &v1::WorkflowValue) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::workflow_value::Kind::Literal(inner) => {
                object.insert(
                    "literal".into(),
                    crate::public::proto_json::encode_value(inner),
                );
            }
            v1::workflow_value::Kind::Object(inner) => {
                object.insert("object".into(), encode_wire_workflow_object_json(inner));
            }
            v1::workflow_value::Kind::Array(inner) => {
                object.insert("array".into(), encode_wire_workflow_array_json(inner));
            }
            v1::workflow_value::Kind::Template(inner) => {
                object.insert("template".into(), encode_wire_workflow_text_json(inner));
            }
            v1::workflow_value::Kind::Input(inner) => {
                object.insert("input".into(), encode_wire_workflow_path_source_json(inner));
            }
            v1::workflow_value::Kind::Signal(inner) => {
                object.insert(
                    "signal".into(),
                    encode_wire_workflow_path_source_json(inner),
                );
            }
            v1::workflow_value::Kind::StepOutput(inner) => {
                object.insert(
                    "stepOutput".into(),
                    encode_wire_workflow_step_output_source_json(inner),
                );
            }
            v1::workflow_value::Kind::StepInput(inner) => {
                object.insert(
                    "stepInput".into(),
                    encode_wire_workflow_step_input_source_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowValue`.
pub(crate) fn decode_wire_workflow_value_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowValue, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowValue {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("literal") {
                active = Some(v1::workflow_value::Kind::Literal(
                    crate::public::proto_json::decode_value(value)?,
                ));
            }
            if let Some(value) = object.get("object") {
                active = Some(v1::workflow_value::Kind::Object(
                    decode_wire_workflow_object_json(value)?,
                ));
            }
            if let Some(value) = object.get("array") {
                active = Some(v1::workflow_value::Kind::Array(
                    decode_wire_workflow_array_json(value)?,
                ));
            }
            if let Some(value) = object.get("template") {
                active = Some(v1::workflow_value::Kind::Template(
                    decode_wire_workflow_text_json(value)?,
                ));
            }
            if let Some(value) = object.get("input") {
                active = Some(v1::workflow_value::Kind::Input(
                    decode_wire_workflow_path_source_json(value)?,
                ));
            }
            if let Some(value) = object.get("signal") {
                active = Some(v1::workflow_value::Kind::Signal(
                    decode_wire_workflow_path_source_json(value)?,
                ));
            }
            if let Some(value) = object.get("stepOutput") {
                active = Some(v1::workflow_value::Kind::StepOutput(
                    decode_wire_workflow_step_output_source_json(value)?,
                ));
            }
            if let Some(value) = object.get("stepInput") {
                active = Some(v1::workflow_value::Kind::StepInput(
                    decode_wire_workflow_step_input_source_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepWhen` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_when_json(
    value: &v1::WorkflowStepWhen,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.value {
        object.insert("value".into(), encode_wire_workflow_value_json(inner));
    }
    if let Some(inner) = &value.equals {
        object.insert(
            "equals".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepWhen`.
pub(crate) fn decode_wire_workflow_step_when_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepWhen, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepWhen {
        value: object
            .get("value")
            .map(|value| decode_wire_workflow_value_json(value))
            .transpose()?,
        equals: object
            .get("equals")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepAppCall` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_app_call_json(
    value: &v1::WorkflowStepAppCall,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if !value.operation.is_empty() {
        object.insert(
            "operation".into(),
            serde_json::Value::String(value.operation.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert("input".into(), encode_wire_workflow_value_json(inner));
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if !value.credential_mode.is_empty() {
        object.insert(
            "credentialMode".into(),
            serde_json::Value::String(value.credential_mode.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepAppCall`.
pub(crate) fn decode_wire_workflow_step_app_call_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepAppCall, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepAppCall {
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        operation: match object.get("operation") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| decode_wire_workflow_value_json(value))
            .transpose()?,
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        credential_mode: match object.get("credentialMode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowAgentMessage` as protobuf JSON.
pub(crate) fn encode_wire_workflow_agent_message_json(
    value: &v1::WorkflowAgentMessage,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.role.is_empty() {
        object.insert(
            "role".into(),
            serde_json::Value::String(value.role.to_string()),
        );
    }
    if let Some(inner) = &value.text {
        object.insert("text".into(), encode_wire_workflow_text_json(inner));
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowAgentMessage`.
pub(crate) fn decode_wire_workflow_agent_message_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowAgentMessage, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowAgentMessage {
        role: match object.get("role") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        text: object
            .get("text")
            .map(|value| decode_wire_workflow_text_json(value))
            .transpose()?,
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepAgentTurn` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_agent_turn_json(
    value: &v1::WorkflowStepAgentTurn,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.model.is_empty() {
        object.insert(
            "model".into(),
            serde_json::Value::String(value.model.to_string()),
        );
    }
    if !value.session_key.is_empty() {
        object.insert(
            "sessionKey".into(),
            serde_json::Value::String(value.session_key.to_string()),
        );
    }
    if let Some(inner) = &value.prompt {
        object.insert("prompt".into(), encode_wire_workflow_text_json(inner));
    }
    if !value.messages.is_empty() {
        object.insert(
            "messages".into(),
            serde_json::Value::Array(
                value
                    .messages
                    .iter()
                    .map(|item| encode_wire_workflow_agent_message_json(item))
                    .collect(),
            ),
        );
    }
    if !value.tools.is_empty() {
        object.insert(
            "tools".into(),
            serde_json::Value::Array(
                value
                    .tools
                    .iter()
                    .map(|item| encode_wire_agent_tool_ref_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.output {
        object.insert("output".into(), encode_wire_agent_output_json(inner));
    }
    if let Some(inner) = &value.model_options {
        object.insert(
            "modelOptions".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepAgentTurn`.
pub(crate) fn decode_wire_workflow_step_agent_turn_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepAgentTurn, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepAgentTurn {
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model: match object.get("model") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        session_key: match object.get("sessionKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        prompt: object
            .get("prompt")
            .map(|value| decode_wire_workflow_text_json(value))
            .transpose()?,
        messages: match object.get("messages") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for messages")
                })?
                .iter()
                .map(|item| decode_wire_workflow_agent_message_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        tools: match object.get("tools") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for tools")
                })?
                .iter()
                .map(|item| decode_wire_agent_tool_ref_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        output: object
            .get("output")
            .map(|value| decode_wire_agent_output_json(value))
            .transpose()?,
        model_options: object
            .get("modelOptions")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStep` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_json(value: &v1::WorkflowStep) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.inputs.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.inputs {
            map.insert(key.clone(), encode_wire_workflow_value_json(value));
        }
        object.insert("inputs".into(), serde_json::Value::Object(map));
    }
    if let Some(inner) = &value.when {
        object.insert("when".into(), encode_wire_workflow_step_when_json(inner));
    }
    if value.timeout_seconds != 0 {
        object.insert(
            "timeoutSeconds".into(),
            serde_json::json!(value.timeout_seconds),
        );
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(active) = &value.action {
        match active {
            v1::workflow_step::Action::App(inner) => {
                object.insert("app".into(), encode_wire_workflow_step_app_call_json(inner));
            }
            v1::workflow_step::Action::Agent(inner) => {
                object.insert(
                    "agent".into(),
                    encode_wire_workflow_step_agent_turn_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStep`.
pub(crate) fn decode_wire_workflow_step_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStep, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStep {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        inputs: match object.get("inputs") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        decode_wire_workflow_value_json(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        when: object
            .get("when")
            .map(|value| decode_wire_workflow_step_when_json(value))
            .transpose()?,
        timeout_seconds: match object.get("timeoutSeconds") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        action: {
            let mut active = None;
            if let Some(value) = object.get("app") {
                active = Some(v1::workflow_step::Action::App(
                    decode_wire_workflow_step_app_call_json(value)?,
                ));
            }
            if let Some(value) = object.get("agent") {
                active = Some(v1::workflow_step::Action::Agent(
                    decode_wire_workflow_step_agent_turn_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `BoundWorkflowTarget` as protobuf JSON.
pub(crate) fn encode_wire_bound_workflow_target_json(
    value: &v1::BoundWorkflowTarget,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.steps.is_empty() {
        object.insert(
            "steps".into(),
            serde_json::Value::Array(
                value
                    .steps
                    .iter()
                    .map(|item| encode_wire_workflow_step_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `BoundWorkflowTarget`.
pub(crate) fn decode_wire_bound_workflow_target_json(
    value: &serde_json::Value,
) -> Result<v1::BoundWorkflowTarget, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::BoundWorkflowTarget {
        steps: match object.get("steps") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for steps")
                })?
                .iter()
                .map(|item| decode_wire_workflow_step_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowScheduleActivation` as protobuf JSON.
pub(crate) fn encode_wire_workflow_schedule_activation_json(
    value: &v1::WorkflowScheduleActivation,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.cron.is_empty() {
        object.insert(
            "cron".into(),
            serde_json::Value::String(value.cron.to_string()),
        );
    }
    if !value.timezone.is_empty() {
        object.insert(
            "timezone".into(),
            serde_json::Value::String(value.timezone.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowScheduleActivation`.
pub(crate) fn decode_wire_workflow_schedule_activation_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowScheduleActivation, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowScheduleActivation {
        cron: match object.get("cron") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        timezone: match object.get("timezone") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowEventMatch` as protobuf JSON.
pub(crate) fn encode_wire_workflow_event_match_json(
    value: &v1::WorkflowEventMatch,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.source.is_empty() {
        object.insert(
            "source".into(),
            serde_json::Value::String(value.source.to_string()),
        );
    }
    if !value.subject.is_empty() {
        object.insert(
            "subject".into(),
            serde_json::Value::String(value.subject.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowEventMatch`.
pub(crate) fn decode_wire_workflow_event_match_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowEventMatch, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowEventMatch {
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        source: match object.get("source") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        subject: match object.get("subject") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowEventActivation` as protobuf JSON.
pub(crate) fn encode_wire_workflow_event_activation_json(
    value: &v1::WorkflowEventActivation,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.r#match {
        object.insert("match".into(), encode_wire_workflow_event_match_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowEventActivation`.
pub(crate) fn decode_wire_workflow_event_activation_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowEventActivation, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowEventActivation {
        r#match: object
            .get("match")
            .map(|value| decode_wire_workflow_event_match_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowActivation` as protobuf JSON.
pub(crate) fn encode_wire_workflow_activation_json(
    value: &v1::WorkflowActivation,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if let Some(inner) = &value.input {
        object.insert("input".into(), encode_wire_workflow_value_json(inner));
    }
    if value.paused {
        object.insert("paused".into(), serde_json::Value::Bool(value.paused));
    }
    if let Some(active) = &value.trigger {
        match active {
            v1::workflow_activation::Trigger::Schedule(inner) => {
                object.insert(
                    "schedule".into(),
                    encode_wire_workflow_schedule_activation_json(inner),
                );
            }
            v1::workflow_activation::Trigger::Event(inner) => {
                object.insert(
                    "event".into(),
                    encode_wire_workflow_event_activation_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowActivation`.
pub(crate) fn decode_wire_workflow_activation_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowActivation, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowActivation {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| decode_wire_workflow_value_json(value))
            .transpose()?,
        paused: match object.get("paused") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        trigger: {
            let mut active = None;
            if let Some(value) = object.get("schedule") {
                active = Some(v1::workflow_activation::Trigger::Schedule(
                    decode_wire_workflow_schedule_activation_json(value)?,
                ));
            }
            if let Some(value) = object.get("event") {
                active = Some(v1::workflow_activation::Trigger::Event(
                    decode_wire_workflow_event_activation_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowDefinitionSpec` as protobuf JSON.
pub(crate) fn encode_wire_workflow_definition_spec_json(
    value: &v1::WorkflowDefinitionSpec,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if let Some(inner) = &value.target {
        object.insert(
            "target".into(),
            encode_wire_bound_workflow_target_json(inner),
        );
    }
    if !value.activations.is_empty() {
        object.insert(
            "activations".into(),
            serde_json::Value::Array(
                value
                    .activations
                    .iter()
                    .map(|item| encode_wire_workflow_activation_json(item))
                    .collect(),
            ),
        );
    }
    if value.paused {
        object.insert("paused".into(), serde_json::Value::Bool(value.paused));
    }
    if !value.run_as.is_empty() {
        object.insert(
            "runAs".into(),
            serde_json::Value::String(value.run_as.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowDefinitionSpec`.
pub(crate) fn decode_wire_workflow_definition_spec_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowDefinitionSpec, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowDefinitionSpec {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        target: object
            .get("target")
            .map(|value| decode_wire_bound_workflow_target_json(value))
            .transpose()?,
        activations: match object.get("activations") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for activations")
                })?
                .iter()
                .map(|item| decode_wire_workflow_activation_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        paused: match object.get("paused") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        run_as: match object.get("runAs") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ApplyWorkflowProviderDefinitionRequest` as protobuf JSON.
pub(crate) fn encode_wire_apply_workflow_provider_definition_request_json(
    value: &v1::ApplyWorkflowProviderDefinitionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if let Some(inner) = &value.spec {
        object.insert(
            "spec".into(),
            encode_wire_workflow_definition_spec_json(inner),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ApplyWorkflowProviderDefinitionRequest`.
pub(crate) fn decode_wire_apply_workflow_provider_definition_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ApplyWorkflowProviderDefinitionRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ApplyWorkflowProviderDefinitionRequest {
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        spec: object
            .get("spec")
            .map(|value| decode_wire_workflow_definition_spec_json(value))
            .transpose()?,
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Converts a native `CancelWorkflowProviderRunRequest` to its wire message.
pub(crate) fn to_wire_cancel_workflow_provider_run_request(
    value: CancelWorkflowProviderRunRequest,
) -> v1::CancelWorkflowProviderRunRequest {
    v1::CancelWorkflowProviderRunRequest {
        run_id: value.run_id,
        reason: value.reason,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `CancelWorkflowProviderRunRequest` as protobuf JSON.
pub(crate) fn encode_wire_cancel_workflow_provider_run_request_json(
    value: &v1::CancelWorkflowProviderRunRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if !value.reason.is_empty() {
        object.insert(
            "reason".into(),
            serde_json::Value::String(value.reason.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CancelWorkflowProviderRunRequest`.
pub(crate) fn decode_wire_cancel_workflow_provider_run_request_json(
    value: &serde_json::Value,
) -> Result<v1::CancelWorkflowProviderRunRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::CancelWorkflowProviderRunRequest {
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        reason: match object.get("reason") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `DeleteWorkflowProviderDefinitionRequest` to its wire message.
pub(crate) fn to_wire_delete_workflow_provider_definition_request(
    value: DeleteWorkflowProviderDefinitionRequest,
) -> v1::DeleteWorkflowProviderDefinitionRequest {
    v1::DeleteWorkflowProviderDefinitionRequest {
        definition_id: value.definition_id,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `DeleteWorkflowProviderDefinitionRequest` as protobuf JSON.
pub(crate) fn encode_wire_delete_workflow_provider_definition_request_json(
    value: &v1::DeleteWorkflowProviderDefinitionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `DeleteWorkflowProviderDefinitionRequest`.
pub(crate) fn decode_wire_delete_workflow_provider_definition_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::DeleteWorkflowProviderDefinitionRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::DeleteWorkflowProviderDefinitionRequest {
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `GetWorkflowProviderDefinitionRequest` to its wire message.
pub(crate) fn to_wire_get_workflow_provider_definition_request(
    value: GetWorkflowProviderDefinitionRequest,
) -> v1::GetWorkflowProviderDefinitionRequest {
    v1::GetWorkflowProviderDefinitionRequest {
        definition_id: value.definition_id,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `GetWorkflowProviderDefinitionRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_definition_request_json(
    value: &v1::GetWorkflowProviderDefinitionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderDefinitionRequest`.
pub(crate) fn decode_wire_get_workflow_provider_definition_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::GetWorkflowProviderDefinitionRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderDefinitionRequest {
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `GetWorkflowProviderRunEventsRequest` to its wire message.
pub(crate) fn to_wire_get_workflow_provider_run_events_request(
    value: GetWorkflowProviderRunEventsRequest,
) -> v1::GetWorkflowProviderRunEventsRequest {
    v1::GetWorkflowProviderRunEventsRequest {
        run_id: value.run_id,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `GetWorkflowProviderRunEventsRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_run_events_request_json(
    value: &v1::GetWorkflowProviderRunEventsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderRunEventsRequest`.
pub(crate) fn decode_wire_get_workflow_provider_run_events_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::GetWorkflowProviderRunEventsRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderRunEventsRequest {
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowRunEvent` as protobuf JSON.
pub(crate) fn encode_wire_workflow_run_event_json(
    value: &v1::WorkflowRunEvent,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if !value.step_id.is_empty() {
        object.insert(
            "stepId".into(),
            serde_json::Value::String(value.step_id.to_string()),
        );
    }
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if let Some(inner) = &value.data {
        object.insert(
            "data".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowRunEvent`.
pub(crate) fn decode_wire_workflow_run_event_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowRunEvent, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowRunEvent {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        step_id: match object.get("stepId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        data: object
            .get("data")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `GetWorkflowProviderRunEventsResponse` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_run_events_response_json(
    value: &v1::GetWorkflowProviderRunEventsResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.events.is_empty() {
        object.insert(
            "events".into(),
            serde_json::Value::Array(
                value
                    .events
                    .iter()
                    .map(|item| encode_wire_workflow_run_event_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderRunEventsResponse`.
pub(crate) fn decode_wire_get_workflow_provider_run_events_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::GetWorkflowProviderRunEventsResponse,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderRunEventsResponse {
        events: match object.get("events") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for events")
                })?
                .iter()
                .map(|item| decode_wire_workflow_run_event_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `GetWorkflowProviderRunOutputRequest` to its wire message.
pub(crate) fn to_wire_get_workflow_provider_run_output_request(
    value: GetWorkflowProviderRunOutputRequest,
) -> v1::GetWorkflowProviderRunOutputRequest {
    v1::GetWorkflowProviderRunOutputRequest {
        run_id: value.run_id,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `GetWorkflowProviderRunOutputRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_run_output_request_json(
    value: &v1::GetWorkflowProviderRunOutputRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderRunOutputRequest`.
pub(crate) fn decode_wire_get_workflow_provider_run_output_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::GetWorkflowProviderRunOutputRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderRunOutputRequest {
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `GetWorkflowProviderRunOutputResponse` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_run_output_response_json(
    value: &v1::GetWorkflowProviderRunOutputResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderRunOutputResponse`.
pub(crate) fn decode_wire_get_workflow_provider_run_output_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::GetWorkflowProviderRunOutputResponse,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderRunOutputResponse {
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Converts a native `GetWorkflowProviderRunRequest` to its wire message.
pub(crate) fn to_wire_get_workflow_provider_run_request(
    value: GetWorkflowProviderRunRequest,
) -> v1::GetWorkflowProviderRunRequest {
    v1::GetWorkflowProviderRunRequest {
        run_id: value.run_id,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `GetWorkflowProviderRunRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_workflow_provider_run_request_json(
    value: &v1::GetWorkflowProviderRunRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetWorkflowProviderRunRequest`.
pub(crate) fn decode_wire_get_workflow_provider_run_request_json(
    value: &serde_json::Value,
) -> Result<v1::GetWorkflowProviderRunRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::GetWorkflowProviderRunRequest {
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListWorkflowProviderDefinitionsRequest` to its wire message.
pub(crate) fn to_wire_list_workflow_provider_definitions_request(
    value: ListWorkflowProviderDefinitionsRequest,
) -> v1::ListWorkflowProviderDefinitionsRequest {
    v1::ListWorkflowProviderDefinitionsRequest {
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `ListWorkflowProviderDefinitionsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_workflow_provider_definitions_request_json(
    value: &v1::ListWorkflowProviderDefinitionsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListWorkflowProviderDefinitionsRequest`.
pub(crate) fn decode_wire_list_workflow_provider_definitions_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListWorkflowProviderDefinitionsRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListWorkflowProviderDefinitionsRequest {
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowDefinition` as protobuf JSON.
pub(crate) fn encode_wire_workflow_definition_json(
    value: &v1::WorkflowDefinition,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if value.generation != 0 {
        object.insert(
            "generation".into(),
            crate::public::proto_json::encode_i64(value.generation),
        );
    }
    if let Some(inner) = &value.target {
        object.insert(
            "target".into(),
            encode_wire_bound_workflow_target_json(inner),
        );
    }
    if !value.activations.is_empty() {
        object.insert(
            "activations".into(),
            serde_json::Value::Array(
                value
                    .activations
                    .iter()
                    .map(|item| encode_wire_workflow_activation_json(item))
                    .collect(),
            ),
        );
    }
    if value.paused {
        object.insert("paused".into(), serde_json::Value::Bool(value.paused));
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.updated_at {
        object.insert(
            "updatedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.run_as.is_empty() {
        object.insert(
            "runAs".into(),
            serde_json::Value::String(value.run_as.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowDefinition`.
pub(crate) fn decode_wire_workflow_definition_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowDefinition, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowDefinition {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        generation: match object.get("generation") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        target: object
            .get("target")
            .map(|value| decode_wire_bound_workflow_target_json(value))
            .transpose()?,
        activations: match object.get("activations") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for activations")
                })?
                .iter()
                .map(|item| decode_wire_workflow_activation_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        paused: match object.get("paused") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        updated_at: object
            .get("updatedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        run_as: match object.get("runAs") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListWorkflowProviderDefinitionsResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_workflow_provider_definitions_response_json(
    value: &v1::ListWorkflowProviderDefinitionsResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.definitions.is_empty() {
        object.insert(
            "definitions".into(),
            serde_json::Value::Array(
                value
                    .definitions
                    .iter()
                    .map(|item| encode_wire_workflow_definition_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListWorkflowProviderDefinitionsResponse`.
pub(crate) fn decode_wire_list_workflow_provider_definitions_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListWorkflowProviderDefinitionsResponse,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListWorkflowProviderDefinitionsResponse {
        definitions: match object.get("definitions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for definitions")
                })?
                .iter()
                .map(|item| decode_wire_workflow_definition_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListWorkflowProviderRunsRequest` to its wire message.
pub(crate) fn to_wire_list_workflow_provider_runs_request(
    value: ListWorkflowProviderRunsRequest,
) -> v1::ListWorkflowProviderRunsRequest {
    v1::ListWorkflowProviderRunsRequest {
        page_size: value.page_size,
        page_token: value.page_token,
        status: value.status,
        target_app: value.target_app,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `ListWorkflowProviderRunsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_workflow_provider_runs_request_json(
    value: &v1::ListWorkflowProviderRunsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.page_size != 0 {
        object.insert("pageSize".into(), serde_json::json!(value.page_size));
    }
    if !value.page_token.is_empty() {
        object.insert(
            "pageToken".into(),
            serde_json::Value::String(value.page_token.to_string()),
        );
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("WORKFLOW_RUN_STATUS_UNSPECIFIED"),
                1 => Some("WORKFLOW_RUN_STATUS_PENDING"),
                2 => Some("WORKFLOW_RUN_STATUS_RUNNING"),
                3 => Some("WORKFLOW_RUN_STATUS_SUCCEEDED"),
                4 => Some("WORKFLOW_RUN_STATUS_FAILED"),
                5 => Some("WORKFLOW_RUN_STATUS_CANCELED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.target_app.is_empty() {
        object.insert(
            "targetApp".into(),
            serde_json::Value::String(value.target_app.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListWorkflowProviderRunsRequest`.
pub(crate) fn decode_wire_list_workflow_provider_runs_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListWorkflowProviderRunsRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListWorkflowProviderRunsRequest {
        page_size: match object.get("pageSize") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        page_token: match object.get("pageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "WORKFLOW_RUN_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "WORKFLOW_RUN_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "WORKFLOW_RUN_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "WORKFLOW_RUN_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "WORKFLOW_RUN_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "WORKFLOW_RUN_STATUS_CANCELED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        target_app: match object.get("targetApp") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowManualTrigger` as protobuf JSON.
pub(crate) fn encode_wire_workflow_manual_trigger_json(
    value: &v1::WorkflowManualTrigger,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowManualTrigger`.
pub(crate) fn decode_wire_workflow_manual_trigger_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowManualTrigger, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowManualTrigger {
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowScheduleTrigger` as protobuf JSON.
pub(crate) fn encode_wire_workflow_schedule_trigger_json(
    value: &v1::WorkflowScheduleTrigger,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.activation_id.is_empty() {
        object.insert(
            "activationId".into(),
            serde_json::Value::String(value.activation_id.to_string()),
        );
    }
    if let Some(inner) = &value.scheduled_for {
        object.insert(
            "scheduledFor".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowScheduleTrigger`.
pub(crate) fn decode_wire_workflow_schedule_trigger_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowScheduleTrigger, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowScheduleTrigger {
        activation_id: match object.get("activationId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scheduled_for: object
            .get("scheduledFor")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowEvent` as protobuf JSON.
pub(crate) fn encode_wire_workflow_event_json(value: &v1::WorkflowEvent) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.source.is_empty() {
        object.insert(
            "source".into(),
            serde_json::Value::String(value.source.to_string()),
        );
    }
    if !value.spec_version.is_empty() {
        object.insert(
            "specVersion".into(),
            serde_json::Value::String(value.spec_version.to_string()),
        );
    }
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.subject.is_empty() {
        object.insert(
            "subject".into(),
            serde_json::Value::String(value.subject.to_string()),
        );
    }
    if let Some(inner) = &value.time {
        object.insert(
            "time".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.datacontenttype.is_empty() {
        object.insert(
            "datacontenttype".into(),
            serde_json::Value::String(value.datacontenttype.to_string()),
        );
    }
    if let Some(inner) = &value.data {
        object.insert(
            "data".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.extensions.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.extensions {
            map.insert(key.clone(), crate::public::proto_json::encode_value(value));
        }
        object.insert("extensions".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowEvent`.
pub(crate) fn decode_wire_workflow_event_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowEvent, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowEvent {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        source: match object.get("source") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        spec_version: match object.get("specVersion") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        subject: match object.get("subject") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        time: object
            .get("time")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        datacontenttype: match object.get("datacontenttype") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        data: object
            .get("data")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        extensions: match object.get("extensions") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        crate::public::proto_json::decode_value(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowEventTriggerInvocation` as protobuf JSON.
pub(crate) fn encode_wire_workflow_event_trigger_invocation_json(
    value: &v1::WorkflowEventTriggerInvocation,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.activation_id.is_empty() {
        object.insert(
            "activationId".into(),
            serde_json::Value::String(value.activation_id.to_string()),
        );
    }
    if let Some(inner) = &value.event {
        object.insert("event".into(), encode_wire_workflow_event_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowEventTriggerInvocation`.
pub(crate) fn decode_wire_workflow_event_trigger_invocation_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowEventTriggerInvocation, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowEventTriggerInvocation {
        activation_id: match object.get("activationId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        event: object
            .get("event")
            .map(|value| decode_wire_workflow_event_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowRunTrigger` as protobuf JSON.
pub(crate) fn encode_wire_workflow_run_trigger_json(
    value: &v1::WorkflowRunTrigger,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::workflow_run_trigger::Kind::Manual(inner) => {
                object.insert(
                    "manual".into(),
                    encode_wire_workflow_manual_trigger_json(inner),
                );
            }
            v1::workflow_run_trigger::Kind::Schedule(inner) => {
                object.insert(
                    "schedule".into(),
                    encode_wire_workflow_schedule_trigger_json(inner),
                );
            }
            v1::workflow_run_trigger::Kind::Event(inner) => {
                object.insert(
                    "event".into(),
                    encode_wire_workflow_event_trigger_invocation_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowRunTrigger`.
pub(crate) fn decode_wire_workflow_run_trigger_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowRunTrigger, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowRunTrigger {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("manual") {
                active = Some(v1::workflow_run_trigger::Kind::Manual(
                    decode_wire_workflow_manual_trigger_json(value)?,
                ));
            }
            if let Some(value) = object.get("schedule") {
                active = Some(v1::workflow_run_trigger::Kind::Schedule(
                    decode_wire_workflow_schedule_trigger_json(value)?,
                ));
            }
            if let Some(value) = object.get("event") {
                active = Some(v1::workflow_run_trigger::Kind::Event(
                    decode_wire_workflow_event_trigger_invocation_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepAttempt` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_attempt_json(
    value: &v1::WorkflowStepAttempt,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("WORKFLOW_STEP_STATUS_UNSPECIFIED"),
                1 => Some("WORKFLOW_STEP_STATUS_PENDING"),
                2 => Some("WORKFLOW_STEP_STATUS_RUNNING"),
                3 => Some("WORKFLOW_STEP_STATUS_SKIPPED"),
                4 => Some("WORKFLOW_STEP_STATUS_SUCCEEDED"),
                5 => Some("WORKFLOW_STEP_STATUS_FAILED"),
                6 => Some("WORKFLOW_STEP_STATUS_UNKNOWN"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if !value.status_message.is_empty() {
        object.insert(
            "statusMessage".into(),
            serde_json::Value::String(value.status_message.to_string()),
        );
    }
    if let Some(inner) = &value.started_at {
        object.insert(
            "startedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.completed_at {
        object.insert(
            "completedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepAttempt`.
pub(crate) fn decode_wire_workflow_step_attempt_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepAttempt, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepAttempt {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "WORKFLOW_STEP_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "WORKFLOW_STEP_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "WORKFLOW_STEP_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "WORKFLOW_STEP_STATUS_SKIPPED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "WORKFLOW_STEP_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "WORKFLOW_STEP_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    "WORKFLOW_STEP_STATUS_UNKNOWN" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(6)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        status_message: match object.get("statusMessage") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        started_at: object
            .get("startedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        completed_at: object
            .get("completedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowStepExecution` as protobuf JSON.
pub(crate) fn encode_wire_workflow_step_execution_json(
    value: &v1::WorkflowStepExecution,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.step_id.is_empty() {
        object.insert(
            "stepId".into(),
            serde_json::Value::String(value.step_id.to_string()),
        );
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("WORKFLOW_STEP_STATUS_UNSPECIFIED"),
                1 => Some("WORKFLOW_STEP_STATUS_PENDING"),
                2 => Some("WORKFLOW_STEP_STATUS_RUNNING"),
                3 => Some("WORKFLOW_STEP_STATUS_SKIPPED"),
                4 => Some("WORKFLOW_STEP_STATUS_SUCCEEDED"),
                5 => Some("WORKFLOW_STEP_STATUS_FAILED"),
                6 => Some("WORKFLOW_STEP_STATUS_UNKNOWN"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.attempts.is_empty() {
        object.insert(
            "attempts".into(),
            serde_json::Value::Array(
                value
                    .attempts
                    .iter()
                    .map(|item| encode_wire_workflow_step_attempt_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if !value.status_message.is_empty() {
        object.insert(
            "statusMessage".into(),
            serde_json::Value::String(value.status_message.to_string()),
        );
    }
    if !value.skip_reason.is_empty() {
        object.insert(
            "skipReason".into(),
            serde_json::Value::String(value.skip_reason.to_string()),
        );
    }
    if let Some(inner) = &value.started_at {
        object.insert(
            "startedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.completed_at {
        object.insert(
            "completedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowStepExecution`.
pub(crate) fn decode_wire_workflow_step_execution_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowStepExecution, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowStepExecution {
        step_id: match object.get("stepId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "WORKFLOW_STEP_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "WORKFLOW_STEP_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "WORKFLOW_STEP_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "WORKFLOW_STEP_STATUS_SKIPPED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "WORKFLOW_STEP_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "WORKFLOW_STEP_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    "WORKFLOW_STEP_STATUS_UNKNOWN" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(6)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        attempts: match object.get("attempts") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for attempts")
                })?
                .iter()
                .map(|item| decode_wire_workflow_step_attempt_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        status_message: match object.get("statusMessage") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        skip_reason: match object.get("skipReason") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        started_at: object
            .get("startedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        completed_at: object
            .get("completedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `WorkflowRun` as protobuf JSON.
pub(crate) fn encode_wire_workflow_run_json(value: &v1::WorkflowRun) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("WORKFLOW_RUN_STATUS_UNSPECIFIED"),
                1 => Some("WORKFLOW_RUN_STATUS_PENDING"),
                2 => Some("WORKFLOW_RUN_STATUS_RUNNING"),
                3 => Some("WORKFLOW_RUN_STATUS_SUCCEEDED"),
                4 => Some("WORKFLOW_RUN_STATUS_FAILED"),
                5 => Some("WORKFLOW_RUN_STATUS_CANCELED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if let Some(inner) = &value.target {
        object.insert(
            "target".into(),
            encode_wire_bound_workflow_target_json(inner),
        );
    }
    if let Some(inner) = &value.trigger {
        object.insert(
            "trigger".into(),
            encode_wire_workflow_run_trigger_json(inner),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.started_at {
        object.insert(
            "startedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.completed_at {
        object.insert(
            "completedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.status_message.is_empty() {
        object.insert(
            "statusMessage".into(),
            serde_json::Value::String(value.status_message.to_string()),
        );
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if !value.workflow_key.is_empty() {
        object.insert(
            "workflowKey".into(),
            serde_json::Value::String(value.workflow_key.to_string()),
        );
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if !value.run_as.is_empty() {
        object.insert(
            "runAs".into(),
            serde_json::Value::String(value.run_as.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if value.definition_generation != 0 {
        object.insert(
            "definitionGeneration".into(),
            crate::public::proto_json::encode_i64(value.definition_generation),
        );
    }
    if !value.current_step_id.is_empty() {
        object.insert(
            "currentStepId".into(),
            serde_json::Value::String(value.current_step_id.to_string()),
        );
    }
    if !value.steps.is_empty() {
        object.insert(
            "steps".into(),
            serde_json::Value::Array(
                value
                    .steps
                    .iter()
                    .map(|item| encode_wire_workflow_step_execution_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowRun`.
pub(crate) fn decode_wire_workflow_run_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowRun, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowRun {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "WORKFLOW_RUN_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "WORKFLOW_RUN_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "WORKFLOW_RUN_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "WORKFLOW_RUN_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "WORKFLOW_RUN_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "WORKFLOW_RUN_STATUS_CANCELED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        target: object
            .get("target")
            .map(|value| decode_wire_bound_workflow_target_json(value))
            .transpose()?,
        trigger: object
            .get("trigger")
            .map(|value| decode_wire_workflow_run_trigger_json(value))
            .transpose()?,
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        started_at: object
            .get("startedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        completed_at: object
            .get("completedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        status_message: match object.get("statusMessage") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        workflow_key: match object.get("workflowKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        run_as: match object.get("runAs") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        definition_generation: match object.get("definitionGeneration") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        current_step_id: match object.get("currentStepId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        steps: match object.get("steps") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for steps")
                })?
                .iter()
                .map(|item| decode_wire_workflow_step_execution_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ListWorkflowProviderRunsResponse` as protobuf JSON.
pub(crate) fn encode_wire_list_workflow_provider_runs_response_json(
    value: &v1::ListWorkflowProviderRunsResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.runs.is_empty() {
        object.insert(
            "runs".into(),
            serde_json::Value::Array(
                value
                    .runs
                    .iter()
                    .map(|item| encode_wire_workflow_run_json(item))
                    .collect(),
            ),
        );
    }
    if !value.next_page_token.is_empty() {
        object.insert(
            "nextPageToken".into(),
            serde_json::Value::String(value.next_page_token.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListWorkflowProviderRunsResponse`.
pub(crate) fn decode_wire_list_workflow_provider_runs_response_json(
    value: &serde_json::Value,
) -> Result<v1::ListWorkflowProviderRunsResponse, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ListWorkflowProviderRunsResponse {
        runs: match object.get("runs") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for runs")
                })?
                .iter()
                .map(|item| decode_wire_workflow_run_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        next_page_token: match object.get("nextPageToken") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `SetWorkflowProviderActivationPausedRequest` to its wire message.
pub(crate) fn to_wire_set_workflow_provider_activation_paused_request(
    value: SetWorkflowProviderActivationPausedRequest,
) -> v1::SetWorkflowProviderActivationPausedRequest {
    v1::SetWorkflowProviderActivationPausedRequest {
        definition_id: value.definition_id,
        activation_id: value.activation_id,
        paused: value.paused,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `SetWorkflowProviderActivationPausedRequest` as protobuf JSON.
pub(crate) fn encode_wire_set_workflow_provider_activation_paused_request_json(
    value: &v1::SetWorkflowProviderActivationPausedRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if !value.activation_id.is_empty() {
        object.insert(
            "activationId".into(),
            serde_json::Value::String(value.activation_id.to_string()),
        );
    }
    if value.paused {
        object.insert("paused".into(), serde_json::Value::Bool(value.paused));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SetWorkflowProviderActivationPausedRequest`.
pub(crate) fn decode_wire_set_workflow_provider_activation_paused_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::SetWorkflowProviderActivationPausedRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SetWorkflowProviderActivationPausedRequest {
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        activation_id: match object.get("activationId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        paused: match object.get("paused") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `SetWorkflowProviderDefinitionPausedRequest` to its wire message.
pub(crate) fn to_wire_set_workflow_provider_definition_paused_request(
    value: SetWorkflowProviderDefinitionPausedRequest,
) -> v1::SetWorkflowProviderDefinitionPausedRequest {
    v1::SetWorkflowProviderDefinitionPausedRequest {
        definition_id: value.definition_id,
        paused: value.paused,
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `SetWorkflowProviderDefinitionPausedRequest` as protobuf JSON.
pub(crate) fn encode_wire_set_workflow_provider_definition_paused_request_json(
    value: &v1::SetWorkflowProviderDefinitionPausedRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if value.paused {
        object.insert("paused".into(), serde_json::Value::Bool(value.paused));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SetWorkflowProviderDefinitionPausedRequest`.
pub(crate) fn decode_wire_set_workflow_provider_definition_paused_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::SetWorkflowProviderDefinitionPausedRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SetWorkflowProviderDefinitionPausedRequest {
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        paused: match object.get("paused") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `SignalOrStartWorkflowProviderRunRequest` to its wire message.
pub(crate) fn to_wire_signal_or_start_workflow_provider_run_request(
    value: SignalOrStartWorkflowProviderRunRequest,
) -> v1::SignalOrStartWorkflowProviderRunRequest {
    v1::SignalOrStartWorkflowProviderRunRequest {
        workflow_key: value.workflow_key,
        idempotency_key: value.idempotency_key,
        signal: value.signal.map(to_wire_workflow_signal),
        provider: value.provider,
        definition_id: value.definition_id,
        input: value.input.map(to_wire_struct),
        expected_definition_generation: value.expected_definition_generation,
        context: None,
        ..Default::default()
    }
}

/// Encodes a wire `WorkflowSignal` as protobuf JSON.
pub(crate) fn encode_wire_workflow_signal_json(value: &v1::WorkflowSignal) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    if let Some(inner) = &value.payload {
        object.insert(
            "payload".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if value.sequence != 0 {
        object.insert(
            "sequence".into(),
            crate::public::proto_json::encode_i64(value.sequence),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `WorkflowSignal`.
pub(crate) fn decode_wire_workflow_signal_json(
    value: &serde_json::Value,
) -> Result<v1::WorkflowSignal, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::WorkflowSignal {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        payload: object
            .get("payload")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        sequence: match object.get("sequence") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        ..Default::default()
    })
}

/// Encodes a wire `SignalOrStartWorkflowProviderRunRequest` as protobuf JSON.
pub(crate) fn encode_wire_signal_or_start_workflow_provider_run_request_json(
    value: &v1::SignalOrStartWorkflowProviderRunRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.workflow_key.is_empty() {
        object.insert(
            "workflowKey".into(),
            serde_json::Value::String(value.workflow_key.to_string()),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if let Some(inner) = &value.signal {
        object.insert("signal".into(), encode_wire_workflow_signal_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if value.expected_definition_generation != 0 {
        object.insert(
            "expectedDefinitionGeneration".into(),
            crate::public::proto_json::encode_i64(value.expected_definition_generation),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SignalOrStartWorkflowProviderRunRequest`.
pub(crate) fn decode_wire_signal_or_start_workflow_provider_run_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::SignalOrStartWorkflowProviderRunRequest,
    crate::public::generated::rpc_support::GestaltError,
> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SignalOrStartWorkflowProviderRunRequest {
        workflow_key: match object.get("workflowKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        signal: object
            .get("signal")
            .map(|value| decode_wire_workflow_signal_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        expected_definition_generation: match object.get("expectedDefinitionGeneration") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Converts a native `SignalWorkflowProviderRunRequest` to its wire message.
pub(crate) fn to_wire_signal_workflow_provider_run_request(
    value: SignalWorkflowProviderRunRequest,
) -> v1::SignalWorkflowProviderRunRequest {
    v1::SignalWorkflowProviderRunRequest {
        run_id: value.run_id,
        signal: value.signal.map(to_wire_workflow_signal),
        context: None,
        provider: value.provider,
        ..Default::default()
    }
}

/// Encodes a wire `SignalWorkflowProviderRunRequest` as protobuf JSON.
pub(crate) fn encode_wire_signal_workflow_provider_run_request_json(
    value: &v1::SignalWorkflowProviderRunRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.run_id.is_empty() {
        object.insert(
            "runId".into(),
            serde_json::Value::String(value.run_id.to_string()),
        );
    }
    if let Some(inner) = &value.signal {
        object.insert("signal".into(), encode_wire_workflow_signal_json(inner));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SignalWorkflowProviderRunRequest`.
pub(crate) fn decode_wire_signal_workflow_provider_run_request_json(
    value: &serde_json::Value,
) -> Result<v1::SignalWorkflowProviderRunRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SignalWorkflowProviderRunRequest {
        run_id: match object.get("runId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        signal: object
            .get("signal")
            .map(|value| decode_wire_workflow_signal_json(value))
            .transpose()?,
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `SignalWorkflowRunResponse` as protobuf JSON.
pub(crate) fn encode_wire_signal_workflow_run_response_json(
    value: &v1::SignalWorkflowRunResponse,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.run {
        object.insert("run".into(), encode_wire_workflow_run_json(inner));
    }
    if let Some(inner) = &value.signal {
        object.insert("signal".into(), encode_wire_workflow_signal_json(inner));
    }
    if value.started_run {
        object.insert(
            "startedRun".into(),
            serde_json::Value::Bool(value.started_run),
        );
    }
    if !value.workflow_key.is_empty() {
        object.insert(
            "workflowKey".into(),
            serde_json::Value::String(value.workflow_key.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SignalWorkflowRunResponse`.
pub(crate) fn decode_wire_signal_workflow_run_response_json(
    value: &serde_json::Value,
) -> Result<v1::SignalWorkflowRunResponse, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SignalWorkflowRunResponse {
        run: object
            .get("run")
            .map(|value| decode_wire_workflow_run_json(value))
            .transpose()?,
        signal: object
            .get("signal")
            .map(|value| decode_wire_workflow_signal_json(value))
            .transpose()?,
        started_run: match object.get("startedRun") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        workflow_key: match object.get("workflowKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `StartWorkflowProviderRunRequest` to its wire message.
pub(crate) fn to_wire_start_workflow_provider_run_request(
    value: StartWorkflowProviderRunRequest,
) -> v1::StartWorkflowProviderRunRequest {
    v1::StartWorkflowProviderRunRequest {
        idempotency_key: value.idempotency_key,
        workflow_key: value.workflow_key,
        provider: value.provider,
        definition_id: value.definition_id,
        input: value.input.map(to_wire_struct),
        expected_definition_generation: value.expected_definition_generation,
        context: None,
        ..Default::default()
    }
}

/// Encodes a wire `StartWorkflowProviderRunRequest` as protobuf JSON.
pub(crate) fn encode_wire_start_workflow_provider_run_request_json(
    value: &v1::StartWorkflowProviderRunRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if !value.workflow_key.is_empty() {
        object.insert(
            "workflowKey".into(),
            serde_json::Value::String(value.workflow_key.to_string()),
        );
    }
    if !value.provider.is_empty() {
        object.insert(
            "provider".into(),
            serde_json::Value::String(value.provider.to_string()),
        );
    }
    if !value.definition_id.is_empty() {
        object.insert(
            "definitionId".into(),
            serde_json::Value::String(value.definition_id.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if value.expected_definition_generation != 0 {
        object.insert(
            "expectedDefinitionGeneration".into(),
            crate::public::proto_json::encode_i64(value.expected_definition_generation),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `StartWorkflowProviderRunRequest`.
pub(crate) fn decode_wire_start_workflow_provider_run_request_json(
    value: &serde_json::Value,
) -> Result<v1::StartWorkflowProviderRunRequest, crate::public::generated::rpc_support::GestaltError>
{
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::StartWorkflowProviderRunRequest {
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        workflow_key: match object.get("workflowKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        provider: match object.get("provider") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        definition_id: match object.get("definitionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        expected_definition_generation: match object.get("expectedDefinitionGeneration") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        ..Default::default()
    })
}