nominal_api/proto/

nominal.procedures.v1.rs

// This file is @generated by prost-build.
/// ProcedureState is the versioned state of a procedure template.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureState {
    /// TODO(niwong): global_fields is deprecated, remove in a future version.
    #[prost(map = "string, message", tag = "1")]
    pub global_fields: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        FormField,
    >,
    /// Global fields are set at the beginning of the procedure execution.
    /// These fields can be referenced by any step in the procedure by using {field_id}.
    #[prost(message, repeated, tag = "5")]
    pub new_global_fields: ::prost::alloc::vec::Vec<FormField>,
    /// A map from node ID to the node.
    #[prost(map = "string, message", tag = "2")]
    pub nodes: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ProcedureNode,
    >,
    /// Section edges represent the visual grouping of sections and steps.
    /// All keys are IDs for section nodes, and all values are lists of IDs for section or step nodes.
    /// { A, \[B, C\] } means that section A visually groups nodes B and C together.
    #[prost(map = "string, message", tag = "3")]
    pub section_edges: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NodeList,
    >,
    /// Step edges represent the dependencies between steps.
    /// All keys and values are IDs for step nodes.
    /// { A, \[B, C\] } means that steps B and C depend on step A to complete to be started
    #[prost(map = "string, message", tag = "4")]
    pub step_edges: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NodeList,
    >,
}
/// A simpler representation of the procedure graph that is used for display in a UI.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureDisplayGraph {
    /// Sections or steps that do not belong to any parent sections.
    /// This is ordered in a topological ordering of steps.
    #[prost(string, repeated, tag = "1")]
    pub top_level_nodes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Map of section node IDs to their topologically sorted children
    #[prost(map = "string, message", tag = "2")]
    pub section_to_sorted_children: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NodeList,
    >,
}
/// A simplified version of procedure state that is currently used for procedure authoring.
/// In this form, the graph is a completely linear structure where each step depends solely
/// on the preceding step.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NestedProcedure {
    /// Title of the procedure
    #[prost(string, tag = "1")]
    pub title: ::prost::alloc::string::String,
    /// Optional long-form description for the procedure
    #[prost(string, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    /// Steps in the procedure
    #[prost(message, repeated, tag = "3")]
    pub steps: ::prost::alloc::vec::Vec<NestedProcedureNode>,
    /// TODO(niwong): global_fields is deprecated, remove in a future version.
    #[prost(map = "string, message", tag = "4")]
    pub global_fields: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        FormField,
    >,
    /// Global fields are set at the beginning of the procedure execution.
    /// These fields can be referenced by any step in the procedure by using {field_id}.
    #[prost(message, repeated, tag = "5")]
    pub new_global_fields: ::prost::alloc::vec::Vec<FormField>,
}
/// A list of node IDs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeList {
    #[prost(string, repeated, tag = "1")]
    pub node_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A procedure node is either a section or a step.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureNode {
    #[prost(oneof = "procedure_node::Node", tags = "1, 2")]
    pub node: ::core::option::Option<procedure_node::Node>,
}
/// Nested message and enum types in `ProcedureNode`.
pub mod procedure_node {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Node {
        /// A section node provides a visual grouping of other sections and steps.
        #[prost(message, tag = "1")]
        Section(super::ProcedureSectionNode),
        /// A step node represents a step in the procedure.
        /// It serves as a "template" for the ExecutionStep that will be created during procedure execution.
        #[prost(message, tag = "2")]
        Step(super::ProcedureStepNode),
    }
}
/// A procedure section node visually groups other sections and steps.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureSectionNode {
    /// Unique identifier for this node in the procedure graph.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Title of this section
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// Optional long-form description for this section
    #[prost(string, optional, tag = "3")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
}
/// A procedure step node represents a step in the procedure.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureStepNode {
    /// Unique identifier for this node in the procedure graph.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Title of this step
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// The content of this step.
    #[prost(message, optional, tag = "3")]
    pub content: ::core::option::Option<ProcedureStepContent>,
    /// Optional long-form description for this step
    #[prost(string, optional, tag = "5")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    /// is_required defaults to false, meaning that the step may be skipped
    #[prost(bool, optional, tag = "6")]
    pub is_required: ::core::option::Option<bool>,
    /// Configuration for if and how the step should automatically transition from NOT_STARTED to IN_PROGRESS
    /// By default, this will be `all_parents`.
    #[prost(message, optional, tag = "7")]
    pub auto_start: ::core::option::Option<AutoStartConfig>,
    /// Configuration for if and how the step should automatically submit the step contents when requirements are met.
    /// By default, this will be `disabled`.
    #[prost(message, optional, tag = "8")]
    pub initial_auto_proceed_config: ::core::option::Option<AutoProceedConfig>,
    /// Configuration for whether the step will require a condition to be met for the step to be completed
    /// By default, this is not set, meaning that the step will not wait on any conditions before completing.
    #[prost(message, optional, tag = "9")]
    pub success_condition: ::core::option::Option<SuccessCondition>,
    /// Configuration for the actions to take when the step transitions to a completed state (SUCCEEDED, ERRORED, SKIPPED)
    /// By default, there are no actions.
    #[prost(message, repeated, tag = "10")]
    pub completion_action_configs: ::prost::alloc::vec::Vec<CompletionActionConfig>,
    /// Optional attachments for the step description
    #[prost(string, repeated, tag = "11")]
    pub attachments: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A section or a step in a NestedProcedure.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NestedProcedureNode {
    /// The unique identifier for this step or section
    #[prost(string, tag = "5")]
    pub id: ::prost::alloc::string::String,
    /// Title of this section or step.
    #[prost(string, tag = "1")]
    pub title: ::prost::alloc::string::String,
    /// Optional long-form description for this section or step.
    #[prost(string, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    /// If this node is a section, then it can contain other sections and steps.
    #[prost(message, repeated, tag = "3")]
    pub steps: ::prost::alloc::vec::Vec<NestedProcedureNode>,
    /// If this node is a step, then this field contains the step definition.
    #[prost(message, optional, tag = "4")]
    pub step: ::core::option::Option<nested_procedure_node::NestedStepNode>,
}
/// Nested message and enum types in `NestedProcedureNode`.
pub mod nested_procedure_node {
    /// These fields' docs are identical to those of ProcedureStepNode.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NestedStepNode {
        #[prost(bool, optional, tag = "2")]
        pub is_required: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "3")]
        pub auto_start: ::core::option::Option<super::AutoStartConfig>,
        #[prost(message, optional, tag = "4")]
        pub initial_auto_proceed_config: ::core::option::Option<
            super::AutoProceedConfig,
        >,
        #[prost(message, optional, tag = "5")]
        pub success_condition: ::core::option::Option<super::SuccessCondition>,
        #[prost(message, repeated, tag = "6")]
        pub completion_action_configs: ::prost::alloc::vec::Vec<
            super::CompletionActionConfig,
        >,
        /// Optional attachments for the step description
        #[prost(string, repeated, tag = "51")]
        pub attachments: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// This should be kept in sync with ProcedureStepContent.content
        #[prost(oneof = "nested_step_node::Content", tags = "7, 8, 9, 10")]
        pub content: ::core::option::Option<nested_step_node::Content>,
    }
    /// Nested message and enum types in `NestedStepNode`.
    pub mod nested_step_node {
        /// This should be kept in sync with ProcedureStepContent.content
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Content {
            #[prost(message, tag = "7")]
            Form(super::super::FormStep),
            #[prost(message, tag = "8")]
            StartIngest(super::super::StartIngestStep),
            #[prost(message, tag = "9")]
            SelectOrCreateAsset(super::super::SelectOrCreateAssetStep),
            #[prost(message, tag = "10")]
            Wait(super::super::WaitStep),
        }
    }
}
/// AutoStartConfig is a configuration that determines whether a step should be
/// automatically moved from NOT_STARTED to IN_PROGRESS when some set of criteria are met.
/// By default this will be `all_parents`
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct AutoStartConfig {
    #[prost(oneof = "auto_start_config::Config", tags = "1, 2")]
    pub config: ::core::option::Option<auto_start_config::Config>,
}
/// Nested message and enum types in `AutoStartConfig`.
pub mod auto_start_config {
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct AllParents {}
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Disabled {}
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Config {
        /// The step will start automatically when all parent steps have passed.
        #[prost(message, tag = "1")]
        AllParents(AllParents),
        /// The step will not start automatically.
        #[prost(message, tag = "2")]
        Disabled(Disabled),
    }
}
/// AutoProceedConfig is a configuration that determines whether a step should
/// automatically proceed (submit the contents and check success_conditions)
/// when some set of criteria are met. By default this will be `disabled`.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct AutoProceedConfig {
    #[prost(oneof = "auto_proceed_config::Config", tags = "1, 2")]
    pub config: ::core::option::Option<auto_proceed_config::Config>,
}
/// Nested message and enum types in `AutoProceedConfig`.
pub mod auto_proceed_config {
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Disabled {}
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Enabled {}
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Config {
        /// The step will not be automatically completed
        #[prost(message, tag = "1")]
        Disabled(Disabled),
        /// The step will automatically submit the step contents once the requirements are met and
        /// begin the transition to either PASSED or ERRORED.
        #[prost(message, tag = "2")]
        Enabled(Enabled),
    }
}
/// The condition that must be met for a step to succeed after submitting its contents.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuccessCondition {
    #[prost(oneof = "success_condition::Condition", tags = "1, 2, 3, 4, 5")]
    pub condition: ::core::option::Option<success_condition::Condition>,
}
/// Nested message and enum types in `SuccessCondition`.
pub mod success_condition {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Condition {
        #[prost(message, tag = "1")]
        And(super::AndSuccessCondition),
        #[prost(message, tag = "2")]
        Timer(super::TimerSuccessCondition),
        #[prost(message, tag = "3")]
        IngestJob(super::IngestJobSuccessCondition),
        #[prost(message, tag = "4")]
        ChannelValidation(super::ChannelValidationSuccessCondition),
        /// OrSuccessCondition or = 6;
        #[prost(message, tag = "5")]
        Webhook(super::WebhookSuccessCondition),
    }
}
/// All conditions within must be met for the step to be succeeded.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AndSuccessCondition {
    #[prost(message, repeated, tag = "1")]
    pub conditions: ::prost::alloc::vec::Vec<SuccessCondition>,
}
/// A timer condition that will succeed the step after a specified duration.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TimerSuccessCondition {
    /// Duration in seconds to wait before succeeding the step. This value must be non-negative.
    /// This duration is a minimum bound; the actual duration may be longer.
    #[prost(int32, tag = "1")]
    pub duration_seconds: i32,
}
/// The step will succeed when the associated ingest job succeeds.
/// If the ingest job fails, the step will move to ERRORED.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IngestJobSuccessCondition {
    /// The field ID that contains the IngestJobRid of the ingest job to monitor.
    #[prost(string, tag = "1")]
    pub field_id: ::prost::alloc::string::String,
}
/// Defines a success condition that compares channel data against a threshold value.
/// The step succeeds when the comparison (channel_value COMPARATOR threshold) evaluates to true
/// within the timeout period. For example, checking if a channel value is greater than 100.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChannelValidationSuccessCondition {
    /// The channel to validate against the threshold.
    #[prost(message, optional, tag = "1")]
    pub channel: ::core::option::Option<
        channel_validation_success_condition::ChannelLocator,
    >,
    /// The comparison operator to use.
    /// COMPARATOR_UNSPECIFIED should never be used and will be rejected at runtime.
    #[prost(enumeration = "channel_validation_success_condition::Comparator", tag = "2")]
    pub comparator: i32,
    /// The threshold value to compare the channel data against.
    /// The comparison is: channel_value COMPARATOR threshold
    /// Using double for better precision. Note: When using COMPARATOR_EQUAL or COMPARATOR_NOT_EQUAL
    /// with floating-point channel data, be aware of potential precision issues inherent to IEEE 754.
    #[prost(double, tag = "3")]
    pub threshold: f64,
    /// Maximum time in milliseconds to wait for the condition to be satisfied.
    /// If the timeout expires before the comparison evaluates to true, the step moves to ERRORED.
    /// Must be greater than zero and at most one hour (3,600,000 milliseconds).
    #[prost(int32, tag = "4")]
    pub timeout_millis: i32,
    /// optionally specify a persistence of individual points
    #[prost(uint32, optional, tag = "5")]
    pub point_persistence: ::core::option::Option<u32>,
    /// optionally specify a persistence duration in milliseconds (max 5 minutes) for which the condition must hold true
    #[prost(uint32, optional, tag = "6")]
    pub time_persistence: ::core::option::Option<u32>,
}
/// Nested message and enum types in `ChannelValidationSuccessCondition`.
pub mod channel_validation_success_condition {
    /// Locates a specific channel within a data source for validation.
    /// Uses symbolic reference names that are resolved to concrete resources at execution time,
    /// allowing procedure templates to be defined before the actual data sources exist.
    /// If the data_source_ref or channel_name cannot be resolved at execution time, the step will
    /// transition to ERRORED state immediately.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ChannelLocator {
        /// Symbolic name for the data source (e.g., "main", "test_data").
        /// This name is resolved to a concrete DataSourceRid at execution time by looking up the name
        /// in the data scopes (for assets) or data sources (for runs) specified by asset_or_run.
        /// This is NOT a field reference - it's a literal string that must match a data source ref name.
        /// Maps to Java type: io.nominal.scout.api.DataSourceRefName
        #[prost(string, tag = "1")]
        pub data_source_ref: ::prost::alloc::string::String,
        /// The name of the channel within the data source to validate.
        /// Maps to Java type: io.nominal.api.Channel
        #[prost(string, tag = "2")]
        pub channel_name: ::prost::alloc::string::String,
        /// Optional series tags to filter the channel data.
        /// Used to select specific series when multiple series exist for the same channel name.
        /// Maps to Java types: io.nominal.api.TagName (key), io.nominal.api.TagValue (value)
        #[prost(map = "string, string", tag = "3")]
        pub tags: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Specifies the context for evaluating the channel data.
        /// Must specify exactly one of: asset reference (for asset-scoped data) or run reference (for run-scoped data).
        #[prost(oneof = "channel_locator::AssetOrRun", tags = "4, 5")]
        pub asset_or_run: ::core::option::Option<channel_locator::AssetOrRun>,
    }
    /// Nested message and enum types in `ChannelLocator`.
    pub mod channel_locator {
        /// Specifies the context for evaluating the channel data.
        /// Must specify exactly one of: asset reference (for asset-scoped data) or run reference (for run-scoped data).
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum AssetOrRun {
            #[prost(message, tag = "4")]
            Asset(super::super::AssetReference),
            #[prost(message, tag = "5")]
            Run(super::super::RunReference),
        }
    }
    /// Comparison operator to evaluate channel value against threshold.
    /// The condition is satisfied when: channel_value COMPARATOR threshold
    /// Example: COMPARATOR_GREATER_THAN with threshold 100.0 means channel_value > 100.0
    ///
    /// Evaluation semantics: The most recent channel value within the timeout period is used for comparison.
    /// If the channel has no data, the condition will continuously retry until timeout_millis expires.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Comparator {
        /// Unspecified comparator. This is an invalid state and should never be used.
        /// Required by proto3 convention as the zero value. Will be rejected at runtime.
        Unspecified = 0,
        GreaterThan = 1,
        GreaterThanOrEqual = 2,
        LessThan = 3,
        LessThanOrEqual = 4,
        Equal = 5,
        NotEqual = 6,
    }
    impl Comparator {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "COMPARATOR_UNSPECIFIED",
                Self::GreaterThan => "COMPARATOR_GREATER_THAN",
                Self::GreaterThanOrEqual => "COMPARATOR_GREATER_THAN_OR_EQUAL",
                Self::LessThan => "COMPARATOR_LESS_THAN",
                Self::LessThanOrEqual => "COMPARATOR_LESS_THAN_OR_EQUAL",
                Self::Equal => "COMPARATOR_EQUAL",
                Self::NotEqual => "COMPARATOR_NOT_EQUAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMPARATOR_UNSPECIFIED" => Some(Self::Unspecified),
                "COMPARATOR_GREATER_THAN" => Some(Self::GreaterThan),
                "COMPARATOR_GREATER_THAN_OR_EQUAL" => Some(Self::GreaterThanOrEqual),
                "COMPARATOR_LESS_THAN" => Some(Self::LessThan),
                "COMPARATOR_LESS_THAN_OR_EQUAL" => Some(Self::LessThanOrEqual),
                "COMPARATOR_EQUAL" => Some(Self::Equal),
                "COMPARATOR_NOT_EQUAL" => Some(Self::NotEqual),
                _ => None,
            }
        }
    }
}
/// A webhook success condition that waits for external system approval via HTTP webhook.
/// The step succeeds when the external system responds with 2xx status code.
///
/// Failure behavior:
/// - 4xx responses: Permanent failure, no retry (CLIENT_ERROR)
/// - 5xx responses: Retry with exponential backoff until max_retries (SERVER_ERROR_MAX_RETRIES_EXCEEDED)
/// - Network errors: Retry until max_retries (NETWORK_ERROR_MAX_RETRIES_EXCEEDED)
/// - Timeout: Retry until timeout_seconds exceeded (OVERALL_TIMEOUT_EXCEEDED)
/// - Redirects: Followed automatically, fails if redirect loop detected (REDIRECT_LOOP)
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebhookSuccessCondition {
    /// RID reference to a WebhookIntegration (the advanced integration type with HMAC signing)
    #[prost(string, tag = "1")]
    pub integration_rid: ::prost::alloc::string::String,
    /// Webhook delivery configuration. If not provided, server uses documented defaults.
    #[prost(message, optional, tag = "2")]
    pub delivery_config: ::core::option::Option<WebhookDeliveryConfig>,
    /// Event type to send (e.g., "procedure.step_waiting")
    #[prost(string, tag = "3")]
    pub event_type: ::prost::alloc::string::String,
    /// JSON payload template using Handlebars syntax (<https://handlebarsjs.com/>)
    /// Supports variable references using {{variable_name}} syntax:
    /// - {{execution_rid}} - Procedure execution RID
    /// - {{step_id}} - Current step ID
    /// - {{step_name}} - Current step name/title
    /// - {{procedure_name}} - Procedure name
    /// - {{field_id}} - Any global form field value (e.g., {{environment}}, {{approval_level}})
    /// - {{asset_rid}} - Asset RID if step has asset context
    /// - {{asset_name}} - Asset name if step has asset context
    ///
    /// Advanced features:
    /// - Conditionals: {{#if environment}}production mode{{/if}}
    /// - Loops: {{#each tags}}{{this}}{{/each}}
    /// - Comparisons: {{#if (eq priority "HIGH")}}urgent{{/if}}
    /// - Default values: {{default environment "unknown"}}
    ///
    /// Example template:
    /// {
    ///    "event": "approval_required",
    ///    "execution_id": "{{execution_rid}}",
    ///    "step": "{{step_name}}",
    ///    "environment": "{{environment}}",
    ///    {{#if asset_name}}
    ///    "asset": "{{asset_name}}",
    ///    {{/if}}
    ///    "is_production": {{#if (eq environment "production")}}true{{else}}false{{/if}}
    /// }
    ///
    /// Variables that cannot be resolved will be replaced with empty string.
    /// Invalid JSON after template evaluation will cause the condition to fail with PAYLOAD_ERROR reason.
    #[prost(string, tag = "4")]
    pub payload_template: ::prost::alloc::string::String,
}
/// Configuration for webhook delivery retry logic and timeouts.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct WebhookDeliveryConfig {
    /// Maximum delivery attempts (default: 3, max: 10)
    #[prost(int32, optional, tag = "1")]
    pub max_retries: ::core::option::Option<i32>,
    /// Initial retry interval seconds (default: 15, min: 5, max: 300)
    #[prost(int64, optional, tag = "2")]
    pub retry_interval_seconds: ::core::option::Option<i64>,
    /// Use exponential backoff (default: true)
    #[prost(bool, optional, tag = "3")]
    pub exponential_backoff: ::core::option::Option<bool>,
    /// Max retry interval seconds (default: 300, max: 3600)
    #[prost(int64, optional, tag = "4")]
    pub max_retry_interval_seconds: ::core::option::Option<i64>,
    /// Overall timeout seconds (default: 600, max: 86400)
    #[prost(int64, optional, tag = "5")]
    pub timeout_seconds: ::core::option::Option<i64>,
}
/// An action that will be taken when a step transitions to a completed state
/// (succeeded, errored, or skipped). These actions are executed after the step
/// contents are submitted and the PassCondition (if any) is satisfied. These
/// actions are executed synchronously with the state transition and generally
/// should be quick to complete.
/// Almost all actions will be executed only if the step transitions to SUCCEEDED.
/// The exception is CreateEvent, which will be executed for all terminal states.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionActionConfig {
    #[prost(oneof = "completion_action_config::Config", tags = "1, 2, 3, 4, 5, 6")]
    pub config: ::core::option::Option<completion_action_config::Config>,
}
/// Nested message and enum types in `CompletionActionConfig`.
pub mod completion_action_config {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Config {
        #[prost(message, tag = "1")]
        CreateEvent(super::CreateEventConfig),
        #[prost(message, tag = "2")]
        SendNotification(super::SendNotificationConfig),
        #[prost(message, tag = "3")]
        CreateRun(super::CreateRunConfig),
        #[prost(message, tag = "4")]
        ApplyWorkbookTemplates(super::ApplyWorkbookTemplatesConfig),
        #[prost(message, tag = "5")]
        ApplyChecklists(super::ApplyChecklistsConfig),
        /// ...
        #[prost(message, tag = "6")]
        UpdateRun(super::UpdateRunConfig),
    }
}
/// An action to create an event when a step is completed.
/// The completion state of the step is mapped to the event's EventType as follows:
/// - SUCCEEDED -> SUCCESS
/// - ERRORED -> ERROR
/// - SKIPPED -> INFO
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEventConfig {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deprecated in favor of property_refs
    /// Properties will be overridden by any property_refs with the same key.
    #[prost(map = "string, string", tag = "4")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Each asset_field_id will be resolved and added as an AssetRid to the created event
    /// deprecated in favor of asset_references
    #[prost(string, repeated, tag = "5")]
    pub asset_field_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The assets to associate the event with. There must be at least one.
    /// asset_references takes precedence over (deprecated) asset_field_ids if both are set.
    ///
    /// TODO(niwong): re-add after client updates \[(buf.validate.field).repeated.min_items = 1\];
    #[prost(message, repeated, tag = "6")]
    pub asset_references: ::prost::alloc::vec::Vec<AssetReference>,
    /// Properties to apply to the event
    #[prost(message, repeated, tag = "7")]
    pub property_refs: ::prost::alloc::vec::Vec<PropertyReference>,
}
/// An action to send a notification to one or more integrations when a step is completed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendNotificationConfig {
    /// The integration(s) to use to send the notification.
    #[prost(message, optional, tag = "1")]
    pub integrations: ::core::option::Option<MultiIntegrationReference>,
    /// The optional title of the notification (length constrained to 130 chars by the IntegrationService).
    #[prost(message, optional, tag = "2")]
    pub title: ::core::option::Option<StringReference>,
    /// The message body of the notification.
    ///
    /// We are omitting some optional parameters to the IntegrationService#sendMessage endpoint,
    /// such as tags, priority, and opsGenieAlias. For all current integration types as of 2025-09-15
    /// (besides OpsGenie), only title and message are used.
    #[prost(message, optional, tag = "3")]
    pub message: ::core::option::Option<StringReference>,
}
/// An action to create a run when a step is completed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateRunConfig {
    /// If present, the run RID for this step will be available in outputs under this field ID.
    #[prost(string, optional, tag = "1")]
    pub run_output_field_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The assets to associate the run with. There must be at least one.
    #[prost(message, optional, tag = "2")]
    pub assets: ::core::option::Option<MultiAssetReference>,
    /// The name of the run.
    #[prost(message, optional, tag = "3")]
    pub name: ::core::option::Option<StringReference>,
    /// Optionally, a description for the run.
    #[prost(message, optional, tag = "4")]
    pub description: ::core::option::Option<StringReference>,
    /// The time range for the run. If unset, the run will be created starting at now() with no end time.
    #[prost(message, optional, tag = "5")]
    pub time_range: ::core::option::Option<TimeRangeReference>,
    /// Labels to apply on the run.
    #[prost(message, optional, tag = "6")]
    pub labels: ::core::option::Option<MultiStringReference>,
    /// Properties to apply on the run.
    ///
    /// repeated UrlReference links;
    /// repeated AttachmentRidReference attachments; // requires some sort of AttachmentRidField where FE handles upload
    #[prost(message, repeated, tag = "7")]
    pub properties: ::prost::alloc::vec::Vec<create_run_config::Property>,
}
/// Nested message and enum types in `CreateRunConfig`.
pub mod create_run_config {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Property {
        #[prost(message, optional, tag = "1")]
        pub key: ::core::option::Option<super::StringReference>,
        #[prost(message, optional, tag = "2")]
        pub value: ::core::option::Option<super::StringReference>,
    }
}
/// An action to update an existing run when a step is completed (e.g. set end time to previous step end time).
///
/// option (buf.validate.message).cel = {
///    id: "update_run_config.at_least_one_update"
///    message: "At least one update field (name, description, time_range, labels, or properties) must be set"
///    expression: "has(this.name) || has(this.description) || has(this.time_range) || has(this.labels) || this.properties.size() > 0"
/// };
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRunConfig {
    /// The run(s) to update. Typically but not limited to a reference to a run created earlier in the procedure
    #[prost(message, optional, tag = "1")]
    pub runs: ::core::option::Option<MultiRunReference>,
    /// Optional PATCH-style updates. Only set fields that should change.
    /// If unset, the run will not be updated.
    #[prost(message, optional, tag = "2")]
    pub name: ::core::option::Option<StringReference>,
    #[prost(message, optional, tag = "3")]
    pub description: ::core::option::Option<StringReference>,
    #[prost(message, optional, tag = "4")]
    pub time_range: ::core::option::Option<TimeRangeReference>,
    /// TODO(ryanyost): support patch-behavior for labels
    #[prost(message, optional, tag = "5")]
    pub labels: ::core::option::Option<MultiStringReference>,
    /// TODO(ryanyost): support patch-behavior for properties
    #[prost(message, repeated, tag = "6")]
    pub properties: ::prost::alloc::vec::Vec<PropertyReference>,
    /// When true, time fields overwrite existing values. When false, start only moves earlier, end only moves later (aligns with runs API strictOverwrite).
    #[prost(bool, optional, tag = "7")]
    pub strict_overwrite: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PropertyReference {
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<StringReference>,
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<StringReference>,
}
/// An action to apply one or more workbook templates to one or more runs when a step is completed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplyWorkbookTemplatesConfig {
    /// The workbook templates to apply.
    #[prost(message, optional, tag = "1")]
    pub workbook_templates: ::core::option::Option<MultiWorkbookTemplateReference>,
    /// The runs to apply the workbook templates to. There must be at least one.
    #[prost(message, optional, tag = "2")]
    pub runs: ::core::option::Option<MultiRunReference>,
}
/// An action to apply one or more checklists to one or more runs when a step is completed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplyChecklistsConfig {
    /// The checklists to apply.
    #[prost(message, optional, tag = "1")]
    pub checklists: ::core::option::Option<MultiChecklistReference>,
    /// The runs to apply the checklists to. There must be at least one.
    #[prost(message, optional, tag = "2")]
    pub runs: ::core::option::Option<MultiRunReference>,
}
/// The content of a procedure step. This typically involves some form of user interaction/input.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureStepContent {
    /// This should be kept in sync with NestedProcedureNode.NestedStepNode.content
    #[prost(oneof = "procedure_step_content::Content", tags = "1, 2, 3, 4")]
    pub content: ::core::option::Option<procedure_step_content::Content>,
}
/// Nested message and enum types in `ProcedureStepContent`.
pub mod procedure_step_content {
    /// This should be kept in sync with NestedProcedureNode.NestedStepNode.content
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        #[prost(message, tag = "1")]
        Form(super::FormStep),
        #[prost(message, tag = "2")]
        StartIngest(super::StartIngestStep),
        #[prost(message, tag = "3")]
        SelectOrCreateAsset(super::SelectOrCreateAssetStep),
        /// ...
        #[prost(message, tag = "4")]
        Wait(super::WaitStep),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct WaitStep {}
/// A form step consists of a set of fields to be filled out by the user.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FormStep {
    #[prost(message, repeated, tag = "1")]
    pub fields: ::prost::alloc::vec::Vec<FormField>,
}
/// The user will be prompted to start an ingest job in the frontend
/// and the output of the step will be the rid of the created ingest job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartIngestStep {
    /// The asset to ingest data into.
    #[prost(message, optional, tag = "1")]
    pub asset: ::core::option::Option<AssetReference>,
    /// The data scope within the asset to ingest data into.
    #[prost(message, optional, tag = "2")]
    pub ref_name: ::core::option::Option<StringReference>,
    /// Restrict and pre-configure the type of ingest that can be started.
    #[prost(message, optional, tag = "3")]
    pub ingest_type_config: ::core::option::Option<start_ingest_step::IngestTypeConfig>,
    /// If present, the ingest job RID for this step will be available in outputs under this field ID.
    #[prost(string, optional, tag = "4")]
    pub ingest_job_output_field_id: ::core::option::Option<
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `StartIngestStep`.
pub mod start_ingest_step {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IngestTypeConfig {
        #[prost(oneof = "ingest_type_config::Config", tags = "1, 2, 3, 4")]
        pub config: ::core::option::Option<ingest_type_config::Config>,
    }
    /// Nested message and enum types in `IngestTypeConfig`.
    pub mod ingest_type_config {
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ContainerizedExtractorIngestConfig {
            /// The ingest job must use this specific containerized extractor.
            #[prost(string, tag = "1")]
            pub rid: ::prost::alloc::string::String,
            /// The step will prompt the user to upload a file for each extractor input that doesn't have a FileInputBinding.
            #[prost(message, repeated, tag = "2")]
            pub file_input_bindings: ::prost::alloc::vec::Vec<
                super::super::FileInputBinding,
            >,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct DataflashIngestConfig {
            /// File to ingest into the dataset. Should be a dataflash `.bin` file.
            /// Uses tags configured on the asset data scope as additional file tags
            #[prost(message, optional, tag = "1")]
            pub file_input: ::core::option::Option<super::super::FileReference>,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct CsvIngestConfig {
            /// header for timestamp column
            #[prost(message, optional, tag = "1")]
            pub timestamp_series_name: ::core::option::Option<
                super::super::StringReference,
            >,
            #[prost(message, optional, tag = "2")]
            pub timestamp_type: ::core::option::Option<
                super::super::TimestampTypeParameter,
            >,
            /// File to ingest into the dataset. Should be a `.csv` or `.csv.gz` file.
            /// Uses tags configured on the asset data scope as additional file tags
            #[prost(message, optional, tag = "3")]
            pub file_input: ::core::option::Option<super::super::FileReference>,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ParquetIngestConfig {
            /// header for timestamp column
            #[prost(message, optional, tag = "1")]
            pub timestamp_series_name: ::core::option::Option<
                super::super::StringReference,
            >,
            #[prost(message, optional, tag = "2")]
            pub timestamp_type: ::core::option::Option<
                super::super::TimestampTypeParameter,
            >,
            /// File to ingest into the dataset. Should be a `.parquet` or `.parquet.gz` file or archive file.
            /// Uses tags configured on the asset data scope as additional file tags
            #[prost(message, optional, tag = "3")]
            pub file_input: ::core::option::Option<super::super::FileReference>,
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Config {
            /// The ingest job must be a containerized extractor ingest.
            #[prost(message, tag = "1")]
            ContainerizedExtractor(ContainerizedExtractorIngestConfig),
            #[prost(message, tag = "2")]
            Dataflash(DataflashIngestConfig),
            #[prost(message, tag = "3")]
            Csv(CsvIngestConfig),
            #[prost(message, tag = "4")]
            Parquet(ParquetIngestConfig),
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileInputBinding {
    /// The input key. For containerized extractors, this is the environment variable name.
    #[prost(string, tag = "1")]
    pub environment_variable: ::prost::alloc::string::String,
    /// The specific type of file
    #[prost(message, optional, tag = "2")]
    pub file_reference: ::core::option::Option<FileReference>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileReference {
    #[prost(oneof = "file_reference::Option", tags = "1")]
    pub option: ::core::option::Option<file_reference::Option>,
}
/// Nested message and enum types in `FileReference`.
pub mod file_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// Reference a field from a prior step
        #[prost(string, tag = "1")]
        FieldId(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimestampTypeParameter {
    #[prost(oneof = "timestamp_type_parameter::Option", tags = "1, 2")]
    pub option: ::core::option::Option<timestamp_type_parameter::Option>,
}
/// Nested message and enum types in `TimestampTypeParameter`.
pub mod timestamp_type_parameter {
    /// Can allow for more configuration
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct UserInputOptions {}
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// Timestamp type to always use for ingest.
        #[prost(message, tag = "1")]
        Constant(super::super::super::types::time::TimestampType),
        /// If specified, allows user to enter timestamp metadata based on input options.
        #[prost(message, tag = "2")]
        UserInput(UserInputOptions),
    }
}
/// The user will be prompted to select an existing asset or create a new asset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SelectOrCreateAssetStep {
    /// If present, the AssetRid for this step will be available in outputs under this field ID.
    #[prost(string, optional, tag = "1")]
    pub asset_output_field_id: ::core::option::Option<::prost::alloc::string::String>,
    /// If present, the user will be given the option to create a new asset restricted by these parameters.
    #[prost(message, optional, tag = "2")]
    pub create_asset_parameters: ::core::option::Option<
        select_or_create_asset_step::CreateAssetParameters,
    >,
    /// The asset selection options for this step.
    /// This can be omitted, in which case the asset can be chosen freely from all assets.
    #[prost(oneof = "select_or_create_asset_step::Options", tags = "3")]
    pub options: ::core::option::Option<select_or_create_asset_step::Options>,
}
/// Nested message and enum types in `SelectOrCreateAssetStep`.
pub mod select_or_create_asset_step {
    /// When creating an new asset, the title is always provided by the user and the
    /// frontend should prompt for it. Other parameters for asset creation can be
    /// specified here as either user-prompted or preset.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CreateAssetParameters {
        /// If set, the new asset will be created with this description.
        #[prost(message, optional, tag = "2")]
        pub description: ::core::option::Option<
            create_asset_parameters::DescriptionParameter,
        >,
        /// If set, the new asset will be created with these labels.
        #[prost(message, optional, tag = "3")]
        pub labels: ::core::option::Option<create_asset_parameters::LabelsParameter>,
        /// If set, the new asset will be created with these properties.
        #[prost(message, optional, tag = "4")]
        pub properties: ::core::option::Option<
            create_asset_parameters::PropertiesParameter,
        >,
        /// Data scopes for the new asset. The keys are the ref names of the data scopes.
        #[prost(map = "string, message", tag = "5")]
        pub data_scopes: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            create_asset_parameters::DataScopeParameter,
        >,
    }
    /// Nested message and enum types in `CreateAssetParameters`.
    pub mod create_asset_parameters {
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct DescriptionParameter {
            #[prost(oneof = "description_parameter::Option", tags = "1")]
            pub option: ::core::option::Option<description_parameter::Option>,
        }
        /// Nested message and enum types in `DescriptionParameter`.
        pub mod description_parameter {
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Option {
                /// The description is always a constant string.
                ///
                /// Can allow for free-form / guardrailed (templated?) user input.
                #[prost(string, tag = "1")]
                Constant(::prost::alloc::string::String),
            }
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct LabelsParameter {
            /// Labels to always apply on the new asset.
            #[prost(string, repeated, tag = "1")]
            pub constant: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// If allowing for user input, the frontend should leverage ResourceMetadataService#listPropertiesAndLabels
            /// to provide the user with existing labels to choose from.
            #[prost(message, optional, tag = "2")]
            pub user_input: ::core::option::Option<labels_parameter::UserInputOptions>,
        }
        /// Nested message and enum types in `LabelsParameter`.
        pub mod labels_parameter {
            /// Can allow for more configuration - e.g. default set of starting labels? (which can be overrideen)
            #[derive(Clone, Copy, PartialEq, ::prost::Message)]
            pub struct UserInputOptions {}
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct PropertiesParameter {
            /// Properties to always apply on the new asset.
            #[prost(map = "string, string", tag = "1")]
            pub constant: ::std::collections::HashMap<
                ::prost::alloc::string::String,
                ::prost::alloc::string::String,
            >,
            /// If allowing for user input, the frontend should leverage ResourceMetadataService#listPropertiesAndLabels
            /// to provide the user with existing property keys/values to choose from.
            #[prost(message, optional, tag = "2")]
            pub user_input: ::core::option::Option<
                properties_parameter::UserInputOptions,
            >,
        }
        /// Nested message and enum types in `PropertiesParameter`.
        pub mod properties_parameter {
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct UserInputOptions {
                /// Each property key here must have a value provided by the user for asset creation.
                #[prost(string, repeated, tag = "1")]
                pub required_keys: ::prost::alloc::vec::Vec<
                    ::prost::alloc::string::String,
                >,
                /// Each property key here will be suggested to the user but is not required for asset creation
                ///
                /// Can allow for more configuration - e.g. required k-v pairs, default k-v pairs?
                #[prost(string, repeated, tag = "2")]
                pub suggested_keys: ::prost::alloc::vec::Vec<
                    ::prost::alloc::string::String,
                >,
            }
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct DataScopeParameter {
            #[prost(message, optional, tag = "21")]
            pub series_tags: ::core::option::Option<super::super::TagsParameter>,
            #[prost(oneof = "data_scope_parameter::DataSource", tags = "1, 2")]
            pub data_source: ::core::option::Option<data_scope_parameter::DataSource>,
        }
        /// Nested message and enum types in `DataScopeParameter`.
        pub mod data_scope_parameter {
            /// The Dataset will be automatically named "{asset}-{ref_name}".
            /// Can later allow for this to be specified.
            /// Other CreateDataset options exist but are omitted for now
            #[derive(Clone, Copy, PartialEq, ::prost::Message)]
            pub struct NewDataset {}
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct ExistingDataset {
                /// The dataset options for this field.
                /// This can be omitted, in which case the dataset can be chosen freely.
                #[prost(oneof = "existing_dataset::Options", tags = "1")]
                pub options: ::core::option::Option<existing_dataset::Options>,
            }
            /// Nested message and enum types in `ExistingDataset`.
            pub mod existing_dataset {
                /// The dataset options for this field.
                /// This can be omitted, in which case the dataset can be chosen freely.
                #[derive(Clone, PartialEq, ::prost::Oneof)]
                pub enum Options {
                    /// The dataset must be chosen from preset options.
                    #[prost(message, tag = "1")]
                    PresetOptions(super::super::super::super::PresetDatasetFieldOptions),
                }
            }
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum DataSource {
                /// Creates a new empty dataset.
                #[prost(message, tag = "1")]
                NewDataset(NewDataset),
                /// Use existing dataset
                #[prost(message, tag = "2")]
                ExistingDataset(ExistingDataset),
            }
        }
    }
    /// The asset selection options for this step.
    /// This can be omitted, in which case the asset can be chosen freely from all assets.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Options {
        /// The asset must be chosen from preset options.
        ///
        /// The asset must be chosen from a saved view.
        /// SavedViewRid saved_view = 4;
        #[prost(message, tag = "3")]
        PresetOptions(super::PresetAssetFieldOptions),
    }
}
/// A limited set of options to choose from, with an optional default option.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PresetDatasetFieldOptions {
    /// The list of options to choose from.
    #[prost(message, repeated, tag = "1")]
    pub options: ::prost::alloc::vec::Vec<DatasetReference>,
    /// If set, this option will be selected by default, if it is present in the options.
    /// The user can still select a different option.
    #[prost(message, optional, tag = "2")]
    pub default_option: ::core::option::Option<DatasetReference>,
}
/// A reference to a single dataset
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetReference {
    #[prost(oneof = "dataset_reference::Option", tags = "1, 2")]
    pub option: ::core::option::Option<dataset_reference::Option>,
}
/// Nested message and enum types in `DatasetReference`.
pub mod dataset_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// a constant DatasetRid
        #[prost(string, tag = "1")]
        Rid(::prost::alloc::string::String),
        /// The field reference that will contain a DatasetRid value. The execution will fail if the field is not set
        /// but the value is accessed.
        #[prost(string, tag = "2")]
        FieldId(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagsParameter {
    /// Tags to always filter to on the dataset or asset data scope.
    #[prost(map = "string, string", tag = "1")]
    pub constant: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// If allowing for user input, the frontend should leverage DataSourceService#getAvailableTagKeys/Values
    /// to provide the user with existing series tag keys/values to choose from.
    #[prost(message, optional, tag = "2")]
    pub user_input: ::core::option::Option<tags_parameter::UserInputOptions>,
}
/// Nested message and enum types in `TagsParameter`.
pub mod tags_parameter {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UserInputOptions {
        /// Each tag key here must have a value provided by the user
        #[prost(string, repeated, tag = "1")]
        pub required_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Each tag key here will be suggested to the user but is not required
        ///
        /// Can allow for more configuration - e.g. required k-v pairs, default k-v pairs?
        #[prost(string, repeated, tag = "2")]
        pub suggested_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
}
/// A reference to multiple string values
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiStringReference {
    #[prost(oneof = "multi_string_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_string_reference::Option>,
}
/// Nested message and enum types in `MultiStringReference`.
pub mod multi_string_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// The value is taken from a field in the current or previous steps.
        #[prost(string, tag = "1")]
        FieldId(::prost::alloc::string::String),
    }
}
/// A reference to a single string value
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StringReference {
    #[prost(oneof = "string_reference::Option", tags = "1, 2")]
    pub option: ::core::option::Option<string_reference::Option>,
}
/// Nested message and enum types in `StringReference`.
pub mod string_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// The value is a constant string
        #[prost(string, tag = "1")]
        Constant(::prost::alloc::string::String),
        /// The value is taken from a field in the current or previous steps.
        ///
        /// TODO(WB-1728): support string templating.
        /// string template = 3;
        #[prost(string, tag = "2")]
        FieldId(::prost::alloc::string::String),
    }
}
/// A reference to multiple assets
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiAssetReference {
    #[prost(oneof = "multi_asset_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_asset_reference::Option>,
}
/// Nested message and enum types in `MultiAssetReference`.
pub mod multi_asset_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AssetReferenceList {
        #[prost(message, repeated, tag = "1")]
        pub references: ::prost::alloc::vec::Vec<super::AssetReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// TODO: add support for a field that contains a list of asset RIDs
        #[prost(message, tag = "1")]
        List(AssetReferenceList),
    }
}
/// A reference to a single asset
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AssetReference {
    #[prost(oneof = "asset_reference::Option", tags = "1, 2")]
    pub option: ::core::option::Option<asset_reference::Option>,
}
/// Nested message and enum types in `AssetReference`.
pub mod asset_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// a constant AssetRid
        #[prost(string, tag = "1")]
        Rid(::prost::alloc::string::String),
        /// The field reference that will contain an AssetRid value. The execution will fail if the field is not set
        /// but the value is accessed.
        #[prost(string, tag = "2")]
        FieldId(::prost::alloc::string::String),
    }
}
/// A reference to a time range
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimeRangeReference {
    #[prost(oneof = "time_range_reference::Option", tags = "1, 2")]
    pub option: ::core::option::Option<time_range_reference::Option>,
}
/// Nested message and enum types in `TimeRangeReference`.
pub mod time_range_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IngestJobList {
        /// Field ids that contain IngestJobRids.
        #[prost(string, repeated, tag = "1")]
        pub field_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RangeLiteral {
        /// If absent, the run's start time will not be set or modified.
        /// For CreateRunConfig, a start time is required (see message-level CEL constraint).
        #[prost(message, optional, tag = "1")]
        pub start: ::core::option::Option<super::TimestampReference>,
        #[prost(message, optional, tag = "2")]
        pub end: ::core::option::Option<super::TimestampReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// The time range is the union of the time ranges ingested by all the specified ingest jobs.
        #[prost(message, tag = "1")]
        FromIngestJobs(IngestJobList),
        #[prost(message, tag = "2")]
        Literal(RangeLiteral),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimestampReference {
    #[prost(oneof = "timestamp_reference::Option", tags = "1, 2")]
    pub option: ::core::option::Option<timestamp_reference::Option>,
}
/// Nested message and enum types in `TimestampReference`.
pub mod timestamp_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// A field reference that resolves to a timestamp from a step's execution state.
        /// Supported field names: started_at, succeeded_at, submitted_at, skipped_at, errored_at.
        /// Aliases: start_time (= started_at), end_time (= succeeded_at).
        #[prost(string, tag = "1")]
        FieldId(::prost::alloc::string::String),
        /// A literal/constant timestamp
        #[prost(message, tag = "2")]
        Constant(super::super::super::super::google::protobuf::Timestamp),
    }
}
/// A reference to multiple runs
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiRunReference {
    #[prost(oneof = "multi_run_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_run_reference::Option>,
}
/// Nested message and enum types in `MultiRunReference`.
pub mod multi_run_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RunReferenceList {
        #[prost(message, repeated, tag = "1")]
        pub references: ::prost::alloc::vec::Vec<super::RunReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// TODO: add support for a field that contains a list of run RIDs
        #[prost(message, tag = "1")]
        List(RunReferenceList),
    }
}
/// A reference to a single run
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunReference {
    #[prost(oneof = "run_reference::Option", tags = "1")]
    pub option: ::core::option::Option<run_reference::Option>,
}
/// Nested message and enum types in `RunReference`.
pub mod run_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// The field id that will contain a RunRid value. The execution will fail if the field is not set properly.
        #[prost(string, tag = "1")]
        FieldId(::prost::alloc::string::String),
    }
}
/// A reference to multiple workbook templates
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiWorkbookTemplateReference {
    #[prost(oneof = "multi_workbook_template_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_workbook_template_reference::Option>,
}
/// Nested message and enum types in `MultiWorkbookTemplateReference`.
pub mod multi_workbook_template_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct WorkbookTemplateReferenceList {
        #[prost(message, repeated, tag = "1")]
        pub references: ::prost::alloc::vec::Vec<super::WorkbookTemplateReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// TODO: add support for a field that contains a list of workbook template RIDs
        #[prost(message, tag = "1")]
        List(WorkbookTemplateReferenceList),
    }
}
/// A reference to a single workbook template
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkbookTemplateReference {
    #[prost(oneof = "workbook_template_reference::Option", tags = "1")]
    pub option: ::core::option::Option<workbook_template_reference::Option>,
}
/// Nested message and enum types in `WorkbookTemplateReference`.
pub mod workbook_template_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// A constant workbook template RID.
        ///
        /// string field_id = 2;
        #[prost(string, tag = "1")]
        Rid(::prost::alloc::string::String),
    }
}
/// A reference to multiple checklists
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiChecklistReference {
    #[prost(oneof = "multi_checklist_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_checklist_reference::Option>,
}
/// Nested message and enum types in `MultiChecklistReference`.
pub mod multi_checklist_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ChecklistReferenceList {
        #[prost(message, repeated, tag = "1")]
        pub references: ::prost::alloc::vec::Vec<super::ChecklistReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// TODO: add support for a field that contains a list of checklist RIDs
        #[prost(message, tag = "1")]
        List(ChecklistReferenceList),
    }
}
/// A reference to a single checklist
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChecklistReference {
    #[prost(oneof = "checklist_reference::Option", tags = "1")]
    pub option: ::core::option::Option<checklist_reference::Option>,
}
/// Nested message and enum types in `ChecklistReference`.
pub mod checklist_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// A constant checklist RID.
        ///
        /// string field_id = 2;
        #[prost(string, tag = "1")]
        Rid(::prost::alloc::string::String),
    }
}
/// A reference to multiple notification Integrations
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiIntegrationReference {
    #[prost(oneof = "multi_integration_reference::Option", tags = "1")]
    pub option: ::core::option::Option<multi_integration_reference::Option>,
}
/// Nested message and enum types in `MultiIntegrationReference`.
pub mod multi_integration_reference {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IntegrationReferenceList {
        #[prost(message, repeated, tag = "1")]
        pub references: ::prost::alloc::vec::Vec<super::IntegrationReference>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        #[prost(message, tag = "1")]
        List(IntegrationReferenceList),
    }
}
/// A reference to a notification Integration
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationReference {
    #[prost(oneof = "integration_reference::Option", tags = "1")]
    pub option: ::core::option::Option<integration_reference::Option>,
}
/// Nested message and enum types in `IntegrationReference`.
pub mod integration_reference {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// A constant integration RID.
        ///
        /// string field_id = 2;
        #[prost(string, tag = "1")]
        Rid(::prost::alloc::string::String),
    }
}
/// A field to be filled out by the user.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FormField {
    /// This field's id can be used by downstream steps to refer to the value.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// UI label for the field component. Overrides any label defined in the specific FormField type.
    #[prost(string, optional, tag = "11")]
    pub label: ::core::option::Option<::prost::alloc::string::String>,
    /// Help text describing how to use this input field.
    #[prost(string, optional, tag = "12")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "form_field::Field", tags = "2, 3, 4, 5, 6, 7, 8, 9, 10")]
    pub field: ::core::option::Option<form_field::Field>,
}
/// Nested message and enum types in `FormField`.
pub mod form_field {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Field {
        #[prost(message, tag = "2")]
        Asset(super::AssetField),
        #[prost(message, tag = "3")]
        Checkbox(super::CheckboxField),
        #[prost(message, tag = "4")]
        Text(super::TextField),
        #[prost(message, tag = "5")]
        Int(super::IntField),
        #[prost(message, tag = "6")]
        Double(super::DoubleField),
        #[prost(message, tag = "7")]
        SingleEnum(super::SingleEnumField),
        #[prost(message, tag = "8")]
        MultiEnum(super::MultiEnumField),
        #[prost(message, tag = "9")]
        FileUpload(super::FileUploadField),
        #[prost(message, tag = "10")]
        MultiFileUpload(super::MultiFileUploadField),
    }
}
/// A limited set of options to choose from, with an optional default option.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PresetAssetFieldOptions {
    /// The list of options to choose from.
    #[prost(message, repeated, tag = "1")]
    pub options: ::prost::alloc::vec::Vec<AssetReference>,
    /// If set, this option will be selected by default, if it is present in the options.
    /// The user can still select a different option.
    #[prost(message, optional, tag = "2")]
    pub default_option: ::core::option::Option<AssetReference>,
}
/// A field to select a single asset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AssetField {
    /// Helper text to guide selection of the asset
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// Whether this field is required to be set complete the step.
    #[prost(bool, tag = "2")]
    pub is_required: bool,
    /// The asset options for this field.
    /// This can be omitted, in which case the asset can be chosen freely from all assets.
    #[prost(oneof = "asset_field::Options", tags = "3")]
    pub options: ::core::option::Option<asset_field::Options>,
}
/// Nested message and enum types in `AssetField`.
pub mod asset_field {
    /// The asset options for this field.
    /// This can be omitted, in which case the asset can be chosen freely from all assets.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Options {
        /// The asset must be chosen from a saved view.
        /// SavedViewRid saved_view = 5;
        /// TODO(pchen): do we want to provide single string types from AssetFieldOption to simplify the Nested
        /// or do we want to explicitly modify the types Nested spec uses?
        #[prost(message, tag = "3")]
        PresetOptions(super::PresetAssetFieldOptions),
    }
}
/// A field to capture a boolean value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CheckboxField {
    /// Label to show for this checkbox field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// If set, the checkbox value must be checked (`true`) to complete the step.
    #[prost(bool, tag = "2")]
    pub is_required: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TextFieldSimpleInputType {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TextFieldMarkdownInputType {}
/// A field to capture a string value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextField {
    /// Label to show for this text field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// if set, validate that input is at least this many characters
    /// `is_required` can be achieved by setting `min_length >= 1`
    #[prost(uint32, optional, tag = "4")]
    pub min_length: ::core::option::Option<u32>,
    /// if set, validate that input is at most this many characters
    #[prost(uint32, optional, tag = "5")]
    pub max_length: ::core::option::Option<u32>,
    /// type of form input to render. Defaults to SIMPLE.
    #[prost(oneof = "text_field::InputType", tags = "2, 3")]
    pub input_type: ::core::option::Option<text_field::InputType>,
}
/// Nested message and enum types in `TextField`.
pub mod text_field {
    /// type of form input to render. Defaults to SIMPLE.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum InputType {
        /// renders a simple html text input field
        #[prost(message, tag = "2")]
        Simple(super::TextFieldSimpleInputType),
        /// renders a Markdown editor for longer inputs with formatting capabilities
        #[prost(message, tag = "3")]
        Markdown(super::TextFieldMarkdownInputType),
    }
}
/// A field to capture an int value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntField {
    /// Label to show for this int field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// Whether this field is required to be set complete the step.
    #[prost(bool, tag = "2")]
    pub is_required: bool,
    /// if set, validate that input is at least this value
    #[prost(int64, optional, tag = "3")]
    pub gte_value: ::core::option::Option<i64>,
    /// if set, validate that input is at most this value
    #[prost(int64, optional, tag = "4")]
    pub lte_value: ::core::option::Option<i64>,
}
/// A field to capture a double value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DoubleField {
    /// Label to show for this double field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// Whether this field is required to be set complete the step.
    #[prost(bool, tag = "2")]
    pub is_required: bool,
    /// if set, a validation on the lower bound of the input value
    #[prost(oneof = "double_field::LowerBound", tags = "3, 4")]
    pub lower_bound: ::core::option::Option<double_field::LowerBound>,
    /// if set, a validation on the upper bound of the input value
    #[prost(oneof = "double_field::UpperBound", tags = "5, 6")]
    pub upper_bound: ::core::option::Option<double_field::UpperBound>,
}
/// Nested message and enum types in `DoubleField`.
pub mod double_field {
    /// if set, a validation on the lower bound of the input value
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum LowerBound {
        /// greater than
        #[prost(double, tag = "3")]
        GtValue(f64),
        /// greater than or equal to
        #[prost(double, tag = "4")]
        GteValue(f64),
    }
    /// if set, a validation on the upper bound of the input value
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum UpperBound {
        /// less than
        #[prost(double, tag = "5")]
        LtValue(f64),
        /// less than or equal to
        #[prost(double, tag = "6")]
        LteValue(f64),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EnumFieldButtonsInputType {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EnumFieldMenuInputType {}
/// A field to capture one of several options.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SingleEnumField {
    /// Label to show for this options field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// List of predefined options that can be selected by the user
    #[prost(string, repeated, tag = "2")]
    pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Whether a user can create and specify a new custom option not in the list of options.
    #[prost(bool, tag = "5")]
    pub allow_custom: bool,
    /// Whether a selection is required
    #[prost(bool, tag = "6")]
    pub is_required: bool,
    /// type of form input to render.
    #[prost(oneof = "single_enum_field::InputType", tags = "3, 4")]
    pub input_type: ::core::option::Option<single_enum_field::InputType>,
}
/// Nested message and enum types in `SingleEnumField`.
pub mod single_enum_field {
    /// type of form input to render.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum InputType {
        /// renders a radio button component
        #[prost(message, tag = "3")]
        Buttons(super::EnumFieldButtonsInputType),
        /// renders a typical drop down menu
        #[prost(message, tag = "4")]
        Dropdown(super::EnumFieldMenuInputType),
    }
}
/// A field to capture one or more of several options.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiEnumField {
    /// Label to show for this options field
    /// deprecated in favor of label directly on FormField
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// List of predefined options that can be selected by the user
    #[prost(string, repeated, tag = "2")]
    pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Whether a user can create and specify a new custom option not in the list of options.
    #[prost(bool, tag = "6")]
    pub allow_custom: bool,
    /// If set, the user must select at least this many options
    /// `is_required` behavior can be achieved by setting `min_count` = 1
    #[prost(uint32, optional, tag = "7")]
    pub min_count: ::core::option::Option<u32>,
    /// If set, the user can select at most this many options
    #[prost(uint32, optional, tag = "8")]
    pub max_count: ::core::option::Option<u32>,
    /// type of form input to render.
    #[prost(oneof = "multi_enum_field::InputType", tags = "3, 4")]
    pub input_type: ::core::option::Option<multi_enum_field::InputType>,
}
/// Nested message and enum types in `MultiEnumField`.
pub mod multi_enum_field {
    /// type of form input to render.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum InputType {
        /// renders a collection of checkboxes
        #[prost(message, tag = "3")]
        Buttons(super::EnumFieldButtonsInputType),
        /// renders a typical drop down menu
        #[prost(message, tag = "4")]
        Dropdown(super::EnumFieldMenuInputType),
    }
}
/// A field to process the uploading of a file
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileUploadField {
    /// If a file is required
    #[prost(bool, tag = "1")]
    pub is_required: bool,
    /// Optional list of case insensitive suffixes to filter files. (ie "csv", "parquet", or "json")
    #[prost(string, repeated, tag = "2")]
    pub suffix_filters: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A field to process the uploading of a dynamic set of files
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiFileUploadField {
    /// Count of required files
    #[prost(uint32, optional, tag = "1")]
    pub min_count: ::core::option::Option<u32>,
    /// File count limit
    #[prost(uint32, optional, tag = "2")]
    pub max_count: ::core::option::Option<u32>,
    /// Optional list of case insensitive suffixes to filter files. (ie "csv", "parquet", or "json")
    #[prost(string, repeated, tag = "3")]
    pub suffix_filters: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Metadata about a procedure that is not part of the versioned state.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureMetadata {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "3")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "4")]
    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(map = "string, string", tag = "5")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(bool, tag = "6")]
    pub is_archived: bool,
    #[prost(bool, tag = "7")]
    pub is_published: bool,
    #[prost(message, optional, tag = "8")]
    pub created_at: ::core::option::Option<
        super::super::super::google::protobuf::Timestamp,
    >,
    #[prost(string, tag = "9")]
    pub created_by: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub updated_at: ::core::option::Option<
        super::super::super::google::protobuf::Timestamp,
    >,
    #[prost(string, tag = "11")]
    pub updated_by: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub workspace: ::prost::alloc::string::String,
}
/// A procedure describes a series of steps to be performed, typically in a specific order,
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Procedure {
    /// The RID of the procedure.
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    /// The commit ID of this version of the procedure.
    #[prost(string, tag = "2")]
    pub commit: ::prost::alloc::string::String,
    /// Metadata about the procedure.
    #[prost(message, optional, tag = "3")]
    pub metadata: ::core::option::Option<ProcedureMetadata>,
    /// The versioned state of the procedure.
    #[prost(message, optional, tag = "4")]
    pub state: ::core::option::Option<ProcedureState>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProcedureRequest {
    #[prost(string, tag = "1")]
    pub title: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(map = "string, string", tag = "4")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, optional, tag = "5")]
    pub state: ::core::option::Option<ProcedureState>,
    #[prost(bool, optional, tag = "6")]
    pub is_published: ::core::option::Option<bool>,
    #[prost(string, tag = "7")]
    pub workspace: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub commit_message: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "9")]
    pub initial_branch_name: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProcedureResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
    #[prost(string, optional, tag = "2")]
    pub branch_name: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProcedureRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub branch_or_commit: ::core::option::Option<
        super::super::versioning::v1::BranchOrCommit,
    >,
    /// If true, the display graph will be included in the response.
    /// Default is false.
    #[prost(bool, tag = "3")]
    pub include_display_graph: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProcedureResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
    /// Included if include_display_graph was set to true
    #[prost(message, optional, tag = "2")]
    pub display_graph: ::core::option::Option<ProcedureDisplayGraph>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetProcedureMetadataRequest {
    #[prost(string, repeated, tag = "1")]
    pub procedure_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetProcedureMetadataResponse {
    #[prost(message, repeated, tag = "1")]
    pub procedure_metadatas: ::prost::alloc::vec::Vec<ProcedureMetadata>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateProcedureMetadataRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub title: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub labels: ::core::option::Option<super::super::types::LabelUpdateWrapper>,
    #[prost(message, optional, tag = "5")]
    pub properties: ::core::option::Option<super::super::types::PropertyUpdateWrapper>,
    #[prost(bool, optional, tag = "6")]
    pub is_archived: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "7")]
    pub is_published: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateProcedureMetadataResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure_metadata: ::core::option::Option<ProcedureMetadata>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParseNestedProcedureRequest {
    #[prost(message, optional, tag = "1")]
    pub nested_procedure: ::core::option::Option<NestedProcedure>,
    /// If true, the display graph will be included in the response.
    /// Default is false.
    #[prost(bool, tag = "3")]
    pub include_display_graph: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParseNestedProcedureResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
    /// Included if include_display_graph was set to true
    #[prost(message, optional, tag = "2")]
    pub display_graph: ::core::option::Option<ProcedureDisplayGraph>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProcedureAsNestedRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub branch_or_commit: ::core::option::Option<
        super::super::versioning::v1::BranchOrCommit,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProcedureAsNestedResponse {
    #[prost(message, optional, tag = "1")]
    pub nested_procedure: ::core::option::Option<NestedProcedure>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MergeToMainRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub branch: ::prost::alloc::string::String,
    /// If present, this commit ID must match the latest commit on main for the merge to succeed.
    #[prost(string, optional, tag = "3")]
    pub latest_commit_on_main: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MergeToMainResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveWorkingStateRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub branch: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "3")]
    pub message: ::prost::alloc::string::String,
    /// If present, this commit ID must match the latest commit on the branch for the save to succeed.
    #[prost(string, optional, tag = "4")]
    pub latest_commit_on_branch: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub state: ::core::option::Option<ProcedureState>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveWorkingStateResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitRequest {
    #[prost(string, tag = "1")]
    pub rid: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub branch: ::core::option::Option<::prost::alloc::string::String>,
    /// If present, this commit ID must match the latest commit on the branch for the commit to succeed.
    #[prost(string, optional, tag = "3")]
    pub latest_commit_on_branch: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub message: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub state: ::core::option::Option<ProcedureState>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitResponse {
    #[prost(message, optional, tag = "1")]
    pub procedure: ::core::option::Option<Procedure>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcedureSearchQuery {
    #[prost(oneof = "procedure_search_query::Query", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
    pub query: ::core::option::Option<procedure_search_query::Query>,
}
/// Nested message and enum types in `ProcedureSearchQuery`.
pub mod procedure_search_query {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ProcedureSearchAndQuery {
        #[prost(message, repeated, tag = "1")]
        pub queries: ::prost::alloc::vec::Vec<super::ProcedureSearchQuery>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ProcedureSearchOrQuery {
        #[prost(message, repeated, tag = "1")]
        pub queries: ::prost::alloc::vec::Vec<super::ProcedureSearchQuery>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Query {
        #[prost(string, tag = "1")]
        SearchText(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        Label(::prost::alloc::string::String),
        #[prost(message, tag = "3")]
        Property(super::super::super::types::Property),
        #[prost(message, tag = "4")]
        And(ProcedureSearchAndQuery),
        #[prost(message, tag = "5")]
        Or(ProcedureSearchOrQuery),
        #[prost(string, tag = "6")]
        Workspace(::prost::alloc::string::String),
        #[prost(string, tag = "7")]
        CreatedBy(::prost::alloc::string::String),
        #[prost(bool, tag = "8")]
        IsArchived(bool),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SearchProceduresSortOptions {
    /// Defaults to true (descending)
    #[prost(bool, optional, tag = "1")]
    pub is_descending: ::core::option::Option<bool>,
    /// Defaults to CREATED_AT
    #[prost(enumeration = "SearchProceduresSortField", optional, tag = "2")]
    pub sort_field: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchProceduresRequest {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<ProcedureSearchQuery>,
    /// If not set, default is to sort by created_at descending
    #[prost(message, optional, tag = "2")]
    pub sort_options: ::core::option::Option<SearchProceduresSortOptions>,
    /// Page sizes greater than 1_000 will be rejected. Default pageSize is 100.
    #[prost(int32, optional, tag = "3")]
    pub page_size: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "4")]
    pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchProceduresResponse {
    #[prost(message, repeated, tag = "1")]
    pub procedure_metadata: ::prost::alloc::vec::Vec<ProcedureMetadata>,
    #[prost(string, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArchiveProceduresRequest {
    #[prost(string, repeated, tag = "1")]
    pub procedure_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArchiveProceduresResponse {
    #[prost(string, repeated, tag = "1")]
    pub procedure_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnarchiveProceduresRequest {
    #[prost(string, repeated, tag = "1")]
    pub procedure_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnarchiveProceduresResponse {
    #[prost(string, repeated, tag = "1")]
    pub procedure_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchProceduresSortField {
    Unspecified = 0,
    Name = 1,
    CreatedAt = 2,
    UpdatedAt = 3,
}
impl SearchProceduresSortField {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SEARCH_PROCEDURES_SORT_FIELD_UNSPECIFIED",
            Self::Name => "SEARCH_PROCEDURES_SORT_FIELD_NAME",
            Self::CreatedAt => "SEARCH_PROCEDURES_SORT_FIELD_CREATED_AT",
            Self::UpdatedAt => "SEARCH_PROCEDURES_SORT_FIELD_UPDATED_AT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SEARCH_PROCEDURES_SORT_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
            "SEARCH_PROCEDURES_SORT_FIELD_NAME" => Some(Self::Name),
            "SEARCH_PROCEDURES_SORT_FIELD_CREATED_AT" => Some(Self::CreatedAt),
            "SEARCH_PROCEDURES_SORT_FIELD_UPDATED_AT" => Some(Self::UpdatedAt),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ProceduresServiceError {
    Unspecified = 0,
    NotFound = 1,
    CommitNotFound = 2,
    CannotMergeMain = 3,
    CannotCommitToArchivedProcedure = 4,
    InvalidGraph = 5,
    InvalidSearchToken = 6,
}
impl ProceduresServiceError {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "PROCEDURES_SERVICE_ERROR_UNSPECIFIED",
            Self::NotFound => "PROCEDURES_SERVICE_ERROR_NOT_FOUND",
            Self::CommitNotFound => "PROCEDURES_SERVICE_ERROR_COMMIT_NOT_FOUND",
            Self::CannotMergeMain => "PROCEDURES_SERVICE_ERROR_CANNOT_MERGE_MAIN",
            Self::CannotCommitToArchivedProcedure => {
                "PROCEDURES_SERVICE_ERROR_CANNOT_COMMIT_TO_ARCHIVED_PROCEDURE"
            }
            Self::InvalidGraph => "PROCEDURES_SERVICE_ERROR_INVALID_GRAPH",
            Self::InvalidSearchToken => "PROCEDURES_SERVICE_ERROR_INVALID_SEARCH_TOKEN",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PROCEDURES_SERVICE_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
            "PROCEDURES_SERVICE_ERROR_NOT_FOUND" => Some(Self::NotFound),
            "PROCEDURES_SERVICE_ERROR_COMMIT_NOT_FOUND" => Some(Self::CommitNotFound),
            "PROCEDURES_SERVICE_ERROR_CANNOT_MERGE_MAIN" => Some(Self::CannotMergeMain),
            "PROCEDURES_SERVICE_ERROR_CANNOT_COMMIT_TO_ARCHIVED_PROCEDURE" => {
                Some(Self::CannotCommitToArchivedProcedure)
            }
            "PROCEDURES_SERVICE_ERROR_INVALID_GRAPH" => Some(Self::InvalidGraph),
            "PROCEDURES_SERVICE_ERROR_INVALID_SEARCH_TOKEN" => {
                Some(Self::InvalidSearchToken)
            }
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod procedures_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for creating and managing procedure templates, which are versioned collections
    /// of steps to be performed, typically in a specific order.
    #[derive(Debug, Clone)]
    pub struct ProceduresServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProceduresServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ProceduresServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ProceduresServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ProceduresServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Create a new procedure
        pub async fn create_procedure(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateProcedureRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateProcedureResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/CreateProcedure",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "CreateProcedure",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a procedure by its RID
        pub async fn get_procedure(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProcedureRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProcedureResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/GetProcedure",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "GetProcedure",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get metadata for multiple procedure by RIDs.
        /// Unauthorized RIDs will be omitted from the response.
        /// Order is not guaranteed to match the request.
        pub async fn batch_get_procedure_metadata(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetProcedureMetadataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetProcedureMetadataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/BatchGetProcedureMetadata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "BatchGetProcedureMetadata",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update the metadata of a procedure
        pub async fn update_procedure_metadata(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateProcedureMetadataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateProcedureMetadataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/UpdateProcedureMetadata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "UpdateProcedureMetadata",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Parse a procedure from a nested procedure structure
        pub async fn parse_nested_procedure(
            &mut self,
            request: impl tonic::IntoRequest<super::ParseNestedProcedureRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ParseNestedProcedureResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/ParseNestedProcedure",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "ParseNestedProcedure",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get procedure as nested procedure
        /// TODO(pchen): in the future, not all graphs will be representable as nested procedures
        pub async fn get_procedure_as_nested(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProcedureAsNestedRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProcedureAsNestedResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/GetProcedureAsNested",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "GetProcedureAsNested",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Merge a branch of a procedure to main
        pub async fn merge_to_main(
            &mut self,
            request: impl tonic::IntoRequest<super::MergeToMainRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MergeToMainResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/MergeToMain",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "MergeToMain",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Save the working state of a procedure
        pub async fn save_working_state(
            &mut self,
            request: impl tonic::IntoRequest<super::SaveWorkingStateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SaveWorkingStateResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/SaveWorkingState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "SaveWorkingState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Commit a procedure to a branch
        pub async fn commit(
            &mut self,
            request: impl tonic::IntoRequest<super::CommitRequest>,
        ) -> std::result::Result<tonic::Response<super::CommitResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/Commit",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("nominal.procedures.v1.ProceduresService", "Commit"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Searches all procedures, returning paged results
        pub async fn search_procedures(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchProceduresRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchProceduresResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/SearchProcedures",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "SearchProcedures",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Archive procedures
        pub async fn archive_procedures(
            &mut self,
            request: impl tonic::IntoRequest<super::ArchiveProceduresRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ArchiveProceduresResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/ArchiveProcedures",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "ArchiveProcedures",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Unarchive procedures
        pub async fn unarchive_procedures(
            &mut self,
            request: impl tonic::IntoRequest<super::UnarchiveProceduresRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UnarchiveProceduresResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/nominal.procedures.v1.ProceduresService/UnarchiveProcedures",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.procedures.v1.ProceduresService",
                        "UnarchiveProcedures",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}