#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Pipeline {
pub id: ::std::string::String,
pub name: ::std::string::String,
pub steps: ::std::vec::Vec<PipelineStep>,
pub _notification_configs: ::std::vec::Vec<super::sp_notify::NotificationConfig>,
pub data_format: ::protobuf::EnumOrUnknown<PipelineDataFormat>,
pub _paused: ::std::option::Option<bool>,
pub _description: ::std::option::Option<::std::string::String>,
pub _version: ::std::option::Option<::std::string::String>,
pub _url: ::std::option::Option<::std::string::String>,
pub _created_at_unix_ts_utc: ::std::option::Option<i64>,
pub _updated_at_unix_ts_utc: ::std::option::Option<i64>,
pub _created_by: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Pipeline {
fn default() -> &'a Pipeline {
<Pipeline as ::protobuf::Message>::default_instance()
}
}
impl Pipeline {
pub fn new() -> Pipeline {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(12);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &Pipeline| { &m.id },
|m: &mut Pipeline| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"name",
|m: &Pipeline| { &m.name },
|m: &mut Pipeline| { &mut m.name },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"steps",
|m: &Pipeline| { &m.steps },
|m: &mut Pipeline| { &mut m.steps },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"_notification_configs",
|m: &Pipeline| { &m._notification_configs },
|m: &mut Pipeline| { &mut m._notification_configs },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"data_format",
|m: &Pipeline| { &m.data_format },
|m: &mut Pipeline| { &mut m.data_format },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_paused",
|m: &Pipeline| { &m._paused },
|m: &mut Pipeline| { &mut m._paused },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_description",
|m: &Pipeline| { &m._description },
|m: &mut Pipeline| { &mut m._description },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_version",
|m: &Pipeline| { &m._version },
|m: &mut Pipeline| { &mut m._version },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_url",
|m: &Pipeline| { &m._url },
|m: &mut Pipeline| { &mut m._url },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_created_at_unix_ts_utc",
|m: &Pipeline| { &m._created_at_unix_ts_utc },
|m: &mut Pipeline| { &mut m._created_at_unix_ts_utc },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_updated_at_unix_ts_utc",
|m: &Pipeline| { &m._updated_at_unix_ts_utc },
|m: &mut Pipeline| { &mut m._updated_at_unix_ts_utc },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_created_by",
|m: &Pipeline| { &m._created_by },
|m: &mut Pipeline| { &mut m._created_by },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Pipeline>(
"Pipeline",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for Pipeline {
const NAME: &'static str = "Pipeline";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
18 => {
self.name = is.read_string()?;
},
26 => {
self.steps.push(is.read_message()?);
},
34 => {
self._notification_configs.push(is.read_message()?);
},
40 => {
self.data_format = is.read_enum_or_unknown()?;
},
8000 => {
self._paused = ::std::option::Option::Some(is.read_bool()?);
},
8010 => {
self._description = ::std::option::Option::Some(is.read_string()?);
},
8018 => {
self._version = ::std::option::Option::Some(is.read_string()?);
},
8026 => {
self._url = ::std::option::Option::Some(is.read_string()?);
},
8032 => {
self._created_at_unix_ts_utc = ::std::option::Option::Some(is.read_int64()?);
},
8040 => {
self._updated_at_unix_ts_utc = ::std::option::Option::Some(is.read_int64()?);
},
8050 => {
self._created_by = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.name);
}
for value in &self.steps {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self._notification_configs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if self.data_format != ::protobuf::EnumOrUnknown::new(PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET) {
my_size += ::protobuf::rt::int32_size(5, self.data_format.value());
}
if let Some(v) = self._paused {
my_size += 2 + 1;
}
if let Some(v) = self._description.as_ref() {
my_size += ::protobuf::rt::string_size(1001, &v);
}
if let Some(v) = self._version.as_ref() {
my_size += ::protobuf::rt::string_size(1002, &v);
}
if let Some(v) = self._url.as_ref() {
my_size += ::protobuf::rt::string_size(1003, &v);
}
if let Some(v) = self._created_at_unix_ts_utc {
my_size += ::protobuf::rt::int64_size(1004, v);
}
if let Some(v) = self._updated_at_unix_ts_utc {
my_size += ::protobuf::rt::int64_size(1005, v);
}
if let Some(v) = self._created_by.as_ref() {
my_size += ::protobuf::rt::string_size(1006, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if !self.name.is_empty() {
os.write_string(2, &self.name)?;
}
for v in &self.steps {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
for v in &self._notification_configs {
::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
};
if self.data_format != ::protobuf::EnumOrUnknown::new(PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET) {
os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.data_format))?;
}
if let Some(v) = self._paused {
os.write_bool(1000, v)?;
}
if let Some(v) = self._description.as_ref() {
os.write_string(1001, v)?;
}
if let Some(v) = self._version.as_ref() {
os.write_string(1002, v)?;
}
if let Some(v) = self._url.as_ref() {
os.write_string(1003, v)?;
}
if let Some(v) = self._created_at_unix_ts_utc {
os.write_int64(1004, v)?;
}
if let Some(v) = self._updated_at_unix_ts_utc {
os.write_int64(1005, v)?;
}
if let Some(v) = self._created_by.as_ref() {
os.write_string(1006, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> Pipeline {
Pipeline::new()
}
fn clear(&mut self) {
self.id.clear();
self.name.clear();
self.steps.clear();
self._notification_configs.clear();
self.data_format = ::protobuf::EnumOrUnknown::new(PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET);
self._paused = ::std::option::Option::None;
self._description = ::std::option::Option::None;
self._version = ::std::option::Option::None;
self._url = ::std::option::Option::None;
self._created_at_unix_ts_utc = ::std::option::Option::None;
self._updated_at_unix_ts_utc = ::std::option::Option::None;
self._created_by = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static Pipeline {
static instance: Pipeline = Pipeline {
id: ::std::string::String::new(),
name: ::std::string::String::new(),
steps: ::std::vec::Vec::new(),
_notification_configs: ::std::vec::Vec::new(),
data_format: ::protobuf::EnumOrUnknown::from_i32(0),
_paused: ::std::option::Option::None,
_description: ::std::option::Option::None,
_version: ::std::option::Option::None,
_url: ::std::option::Option::None,
_created_at_unix_ts_utc: ::std::option::Option::None,
_updated_at_unix_ts_utc: ::std::option::Option::None,
_created_by: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for Pipeline {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("Pipeline").unwrap()).clone()
}
}
impl ::std::fmt::Display for Pipeline {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Pipeline {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineStepConditions {
pub abort: ::protobuf::EnumOrUnknown<AbortCondition>,
pub notify: bool,
pub metadata: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
pub notification: ::protobuf::MessageField<PipelineStepNotification>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineStepConditions {
fn default() -> &'a PipelineStepConditions {
<PipelineStepConditions as ::protobuf::Message>::default_instance()
}
}
impl PipelineStepConditions {
pub fn new() -> PipelineStepConditions {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(4);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"abort",
|m: &PipelineStepConditions| { &m.abort },
|m: &mut PipelineStepConditions| { &mut m.abort },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"notify",
|m: &PipelineStepConditions| { &m.notify },
|m: &mut PipelineStepConditions| { &mut m.notify },
));
fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor::<_, _, _>(
"metadata",
|m: &PipelineStepConditions| { &m.metadata },
|m: &mut PipelineStepConditions| { &mut m.metadata },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, PipelineStepNotification>(
"notification",
|m: &PipelineStepConditions| { &m.notification },
|m: &mut PipelineStepConditions| { &mut m.notification },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineStepConditions>(
"PipelineStepConditions",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineStepConditions {
const NAME: &'static str = "PipelineStepConditions";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.abort = is.read_enum_or_unknown()?;
},
16 => {
self.notify = is.read_bool()?;
},
26 => {
let len = is.read_raw_varint32()?;
let old_limit = is.push_limit(len as u64)?;
let mut key = ::std::default::Default::default();
let mut value = ::std::default::Default::default();
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => key = is.read_string()?,
18 => value = is.read_string()?,
_ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
};
}
is.pop_limit(old_limit);
self.metadata.insert(key, value);
},
34 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.notification)?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.abort != ::protobuf::EnumOrUnknown::new(AbortCondition::ABORT_CONDITION_UNSET) {
my_size += ::protobuf::rt::int32_size(1, self.abort.value());
}
if self.notify != false {
my_size += 1 + 1;
}
for (k, v) in &self.metadata {
let mut entry_size = 0;
entry_size += ::protobuf::rt::string_size(1, &k);
entry_size += ::protobuf::rt::string_size(2, &v);
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
};
if let Some(v) = self.notification.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.abort != ::protobuf::EnumOrUnknown::new(AbortCondition::ABORT_CONDITION_UNSET) {
os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.abort))?;
}
if self.notify != false {
os.write_bool(2, self.notify)?;
}
for (k, v) in &self.metadata {
let mut entry_size = 0;
entry_size += ::protobuf::rt::string_size(1, &k);
entry_size += ::protobuf::rt::string_size(2, &v);
os.write_raw_varint32(26)?; os.write_raw_varint32(entry_size as u32)?;
os.write_string(1, &k)?;
os.write_string(2, &v)?;
};
if let Some(v) = self.notification.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineStepConditions {
PipelineStepConditions::new()
}
fn clear(&mut self) {
self.abort = ::protobuf::EnumOrUnknown::new(AbortCondition::ABORT_CONDITION_UNSET);
self.notify = false;
self.metadata.clear();
self.notification.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineStepConditions {
static instance: ::protobuf::rt::Lazy<PipelineStepConditions> = ::protobuf::rt::Lazy::new();
instance.get(PipelineStepConditions::new)
}
}
impl ::protobuf::MessageFull for PipelineStepConditions {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineStepConditions").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineStepConditions {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineStepConditions {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineStepNotification {
pub notification_config_ids: ::std::vec::Vec<::std::string::String>,
pub payload_type: ::protobuf::EnumOrUnknown<pipeline_step_notification::PayloadType>,
pub paths: ::std::vec::Vec<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineStepNotification {
fn default() -> &'a PipelineStepNotification {
<PipelineStepNotification as ::protobuf::Message>::default_instance()
}
}
impl PipelineStepNotification {
pub fn new() -> PipelineStepNotification {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"notification_config_ids",
|m: &PipelineStepNotification| { &m.notification_config_ids },
|m: &mut PipelineStepNotification| { &mut m.notification_config_ids },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"payload_type",
|m: &PipelineStepNotification| { &m.payload_type },
|m: &mut PipelineStepNotification| { &mut m.payload_type },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"paths",
|m: &PipelineStepNotification| { &m.paths },
|m: &mut PipelineStepNotification| { &mut m.paths },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineStepNotification>(
"PipelineStepNotification",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineStepNotification {
const NAME: &'static str = "PipelineStepNotification";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.notification_config_ids.push(is.read_string()?);
},
16 => {
self.payload_type = is.read_enum_or_unknown()?;
},
26 => {
self.paths.push(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.notification_config_ids {
my_size += ::protobuf::rt::string_size(1, &value);
};
if self.payload_type != ::protobuf::EnumOrUnknown::new(pipeline_step_notification::PayloadType::PAYLOAD_TYPE_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.payload_type.value());
}
for value in &self.paths {
my_size += ::protobuf::rt::string_size(3, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.notification_config_ids {
os.write_string(1, &v)?;
};
if self.payload_type != ::protobuf::EnumOrUnknown::new(pipeline_step_notification::PayloadType::PAYLOAD_TYPE_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.payload_type))?;
}
for v in &self.paths {
os.write_string(3, &v)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineStepNotification {
PipelineStepNotification::new()
}
fn clear(&mut self) {
self.notification_config_ids.clear();
self.payload_type = ::protobuf::EnumOrUnknown::new(pipeline_step_notification::PayloadType::PAYLOAD_TYPE_UNSET);
self.paths.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineStepNotification {
static instance: PipelineStepNotification = PipelineStepNotification {
notification_config_ids: ::std::vec::Vec::new(),
payload_type: ::protobuf::EnumOrUnknown::from_i32(0),
paths: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineStepNotification {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineStepNotification").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineStepNotification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineStepNotification {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod pipeline_step_notification {
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum PayloadType {
PAYLOAD_TYPE_UNSET = 0,
PAYLOAD_TYPE_EXCLUDE = 1,
PAYLOAD_TYPE_FULL_PAYLOAD = 2,
PAYLOAD_TYPE_SELECT_PATHS = 3,
}
impl ::protobuf::Enum for PayloadType {
const NAME: &'static str = "PayloadType";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<PayloadType> {
match value {
0 => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_UNSET),
1 => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_EXCLUDE),
2 => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_FULL_PAYLOAD),
3 => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_SELECT_PATHS),
_ => ::std::option::Option::None
}
}
fn from_str(str: &str) -> ::std::option::Option<PayloadType> {
match str {
"PAYLOAD_TYPE_UNSET" => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_UNSET),
"PAYLOAD_TYPE_EXCLUDE" => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_EXCLUDE),
"PAYLOAD_TYPE_FULL_PAYLOAD" => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_FULL_PAYLOAD),
"PAYLOAD_TYPE_SELECT_PATHS" => ::std::option::Option::Some(PayloadType::PAYLOAD_TYPE_SELECT_PATHS),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [PayloadType] = &[
PayloadType::PAYLOAD_TYPE_UNSET,
PayloadType::PAYLOAD_TYPE_EXCLUDE,
PayloadType::PAYLOAD_TYPE_FULL_PAYLOAD,
PayloadType::PAYLOAD_TYPE_SELECT_PATHS,
];
}
impl ::protobuf::EnumFull for PayloadType {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("PipelineStepNotification.PayloadType").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for PayloadType {
fn default() -> Self {
PayloadType::PAYLOAD_TYPE_UNSET
}
}
impl PayloadType {
pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<PayloadType>("PipelineStepNotification.PayloadType")
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineStep {
pub name: ::std::string::String,
pub on_true: ::protobuf::MessageField<PipelineStepConditions>,
pub on_false: ::protobuf::MessageField<PipelineStepConditions>,
pub dynamic: bool,
pub on_error: ::protobuf::MessageField<PipelineStepConditions>,
pub _wasm_id: ::std::option::Option<::std::string::String>,
pub _wasm_bytes: ::std::option::Option<::std::vec::Vec<u8>>,
pub _wasm_function: ::std::option::Option<::std::string::String>,
pub step: ::std::option::Option<pipeline_step::Step>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineStep {
fn default() -> &'a PipelineStep {
<PipelineStep as ::protobuf::Message>::default_instance()
}
}
impl PipelineStep {
pub fn new() -> PipelineStep {
::std::default::Default::default()
}
pub fn detective(&self) -> &super::sp_steps_detective::DetectiveStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(ref v)) => v,
_ => <super::sp_steps_detective::DetectiveStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_detective(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_detective(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(..)) => true,
_ => false,
}
}
pub fn set_detective(&mut self, v: super::sp_steps_detective::DetectiveStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(v))
}
pub fn mut_detective(&mut self) -> &mut super::sp_steps_detective::DetectiveStep {
if let ::std::option::Option::Some(pipeline_step::Step::Detective(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(super::sp_steps_detective::DetectiveStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_detective(&mut self) -> super::sp_steps_detective::DetectiveStep {
if self.has_detective() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Detective(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_detective::DetectiveStep::new()
}
}
pub fn transform(&self) -> &super::sp_steps_transform::TransformStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(ref v)) => v,
_ => <super::sp_steps_transform::TransformStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_transform(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_transform(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(..)) => true,
_ => false,
}
}
pub fn set_transform(&mut self, v: super::sp_steps_transform::TransformStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(v))
}
pub fn mut_transform(&mut self) -> &mut super::sp_steps_transform::TransformStep {
if let ::std::option::Option::Some(pipeline_step::Step::Transform(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(super::sp_steps_transform::TransformStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_transform(&mut self) -> super::sp_steps_transform::TransformStep {
if self.has_transform() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Transform(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_transform::TransformStep::new()
}
}
pub fn encode(&self) -> &super::sp_steps_encode::EncodeStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(ref v)) => v,
_ => <super::sp_steps_encode::EncodeStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_encode(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_encode(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(..)) => true,
_ => false,
}
}
pub fn set_encode(&mut self, v: super::sp_steps_encode::EncodeStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(v))
}
pub fn mut_encode(&mut self) -> &mut super::sp_steps_encode::EncodeStep {
if let ::std::option::Option::Some(pipeline_step::Step::Encode(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(super::sp_steps_encode::EncodeStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_encode(&mut self) -> super::sp_steps_encode::EncodeStep {
if self.has_encode() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Encode(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_encode::EncodeStep::new()
}
}
pub fn decode(&self) -> &super::sp_steps_decode::DecodeStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(ref v)) => v,
_ => <super::sp_steps_decode::DecodeStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_decode(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_decode(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(..)) => true,
_ => false,
}
}
pub fn set_decode(&mut self, v: super::sp_steps_decode::DecodeStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(v))
}
pub fn mut_decode(&mut self) -> &mut super::sp_steps_decode::DecodeStep {
if let ::std::option::Option::Some(pipeline_step::Step::Decode(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(super::sp_steps_decode::DecodeStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_decode(&mut self) -> super::sp_steps_decode::DecodeStep {
if self.has_decode() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Decode(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_decode::DecodeStep::new()
}
}
pub fn custom(&self) -> &super::sp_steps_custom::CustomStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(ref v)) => v,
_ => <super::sp_steps_custom::CustomStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_custom(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_custom(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(..)) => true,
_ => false,
}
}
pub fn set_custom(&mut self, v: super::sp_steps_custom::CustomStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(v))
}
pub fn mut_custom(&mut self) -> &mut super::sp_steps_custom::CustomStep {
if let ::std::option::Option::Some(pipeline_step::Step::Custom(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(super::sp_steps_custom::CustomStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_custom(&mut self) -> super::sp_steps_custom::CustomStep {
if self.has_custom() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Custom(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_custom::CustomStep::new()
}
}
pub fn http_request(&self) -> &super::sp_steps_httprequest::HttpRequestStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::HttpRequest(ref v)) => v,
_ => <super::sp_steps_httprequest::HttpRequestStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_http_request(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_http_request(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::HttpRequest(..)) => true,
_ => false,
}
}
pub fn set_http_request(&mut self, v: super::sp_steps_httprequest::HttpRequestStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::HttpRequest(v))
}
pub fn mut_http_request(&mut self) -> &mut super::sp_steps_httprequest::HttpRequestStep {
if let ::std::option::Option::Some(pipeline_step::Step::HttpRequest(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::HttpRequest(super::sp_steps_httprequest::HttpRequestStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::HttpRequest(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_http_request(&mut self) -> super::sp_steps_httprequest::HttpRequestStep {
if self.has_http_request() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::HttpRequest(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_httprequest::HttpRequestStep::new()
}
}
pub fn kv(&self) -> &super::sp_steps_kv::KVStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Kv(ref v)) => v,
_ => <super::sp_steps_kv::KVStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_kv(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_kv(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Kv(..)) => true,
_ => false,
}
}
pub fn set_kv(&mut self, v: super::sp_steps_kv::KVStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Kv(v))
}
pub fn mut_kv(&mut self) -> &mut super::sp_steps_kv::KVStep {
if let ::std::option::Option::Some(pipeline_step::Step::Kv(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Kv(super::sp_steps_kv::KVStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Kv(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_kv(&mut self) -> super::sp_steps_kv::KVStep {
if self.has_kv() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Kv(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_kv::KVStep::new()
}
}
pub fn infer_schema(&self) -> &super::sp_steps_inferschema::InferSchemaStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::InferSchema(ref v)) => v,
_ => <super::sp_steps_inferschema::InferSchemaStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_infer_schema(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_infer_schema(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::InferSchema(..)) => true,
_ => false,
}
}
pub fn set_infer_schema(&mut self, v: super::sp_steps_inferschema::InferSchemaStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::InferSchema(v))
}
pub fn mut_infer_schema(&mut self) -> &mut super::sp_steps_inferschema::InferSchemaStep {
if let ::std::option::Option::Some(pipeline_step::Step::InferSchema(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::InferSchema(super::sp_steps_inferschema::InferSchemaStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::InferSchema(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_infer_schema(&mut self) -> super::sp_steps_inferschema::InferSchemaStep {
if self.has_infer_schema() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::InferSchema(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_inferschema::InferSchemaStep::new()
}
}
pub fn valid_json(&self) -> &super::sp_steps_valid_json::ValidJSONStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::ValidJson(ref v)) => v,
_ => <super::sp_steps_valid_json::ValidJSONStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_valid_json(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_valid_json(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::ValidJson(..)) => true,
_ => false,
}
}
pub fn set_valid_json(&mut self, v: super::sp_steps_valid_json::ValidJSONStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::ValidJson(v))
}
pub fn mut_valid_json(&mut self) -> &mut super::sp_steps_valid_json::ValidJSONStep {
if let ::std::option::Option::Some(pipeline_step::Step::ValidJson(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::ValidJson(super::sp_steps_valid_json::ValidJSONStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::ValidJson(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_valid_json(&mut self) -> super::sp_steps_valid_json::ValidJSONStep {
if self.has_valid_json() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::ValidJson(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_valid_json::ValidJSONStep::new()
}
}
pub fn schema_validation(&self) -> &super::sp_steps_schema_validation::SchemaValidationStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::SchemaValidation(ref v)) => v,
_ => <super::sp_steps_schema_validation::SchemaValidationStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_schema_validation(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_schema_validation(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::SchemaValidation(..)) => true,
_ => false,
}
}
pub fn set_schema_validation(&mut self, v: super::sp_steps_schema_validation::SchemaValidationStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::SchemaValidation(v))
}
pub fn mut_schema_validation(&mut self) -> &mut super::sp_steps_schema_validation::SchemaValidationStep {
if let ::std::option::Option::Some(pipeline_step::Step::SchemaValidation(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::SchemaValidation(super::sp_steps_schema_validation::SchemaValidationStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::SchemaValidation(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_schema_validation(&mut self) -> super::sp_steps_schema_validation::SchemaValidationStep {
if self.has_schema_validation() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::SchemaValidation(v)) => v,
_ => panic!(),
}
} else {
super::sp_steps_schema_validation::SchemaValidationStep::new()
}
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(18);
let mut oneofs = ::std::vec::Vec::with_capacity(1);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"name",
|m: &PipelineStep| { &m.name },
|m: &mut PipelineStep| { &mut m.name },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, PipelineStepConditions>(
"on_true",
|m: &PipelineStep| { &m.on_true },
|m: &mut PipelineStep| { &mut m.on_true },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, PipelineStepConditions>(
"on_false",
|m: &PipelineStep| { &m.on_false },
|m: &mut PipelineStep| { &mut m.on_false },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"dynamic",
|m: &PipelineStep| { &m.dynamic },
|m: &mut PipelineStep| { &mut m.dynamic },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, PipelineStepConditions>(
"on_error",
|m: &PipelineStep| { &m.on_error },
|m: &mut PipelineStep| { &mut m.on_error },
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_detective::DetectiveStep>(
"detective",
PipelineStep::has_detective,
PipelineStep::detective,
PipelineStep::mut_detective,
PipelineStep::set_detective,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_transform::TransformStep>(
"transform",
PipelineStep::has_transform,
PipelineStep::transform,
PipelineStep::mut_transform,
PipelineStep::set_transform,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_encode::EncodeStep>(
"encode",
PipelineStep::has_encode,
PipelineStep::encode,
PipelineStep::mut_encode,
PipelineStep::set_encode,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_decode::DecodeStep>(
"decode",
PipelineStep::has_decode,
PipelineStep::decode,
PipelineStep::mut_decode,
PipelineStep::set_decode,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_custom::CustomStep>(
"custom",
PipelineStep::has_custom,
PipelineStep::custom,
PipelineStep::mut_custom,
PipelineStep::set_custom,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_httprequest::HttpRequestStep>(
"http_request",
PipelineStep::has_http_request,
PipelineStep::http_request,
PipelineStep::mut_http_request,
PipelineStep::set_http_request,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_kv::KVStep>(
"kv",
PipelineStep::has_kv,
PipelineStep::kv,
PipelineStep::mut_kv,
PipelineStep::set_kv,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_inferschema::InferSchemaStep>(
"infer_schema",
PipelineStep::has_infer_schema,
PipelineStep::infer_schema,
PipelineStep::mut_infer_schema,
PipelineStep::set_infer_schema,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_valid_json::ValidJSONStep>(
"valid_json",
PipelineStep::has_valid_json,
PipelineStep::valid_json,
PipelineStep::mut_valid_json,
PipelineStep::set_valid_json,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::sp_steps_schema_validation::SchemaValidationStep>(
"schema_validation",
PipelineStep::has_schema_validation,
PipelineStep::schema_validation,
PipelineStep::mut_schema_validation,
PipelineStep::set_schema_validation,
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_wasm_id",
|m: &PipelineStep| { &m._wasm_id },
|m: &mut PipelineStep| { &mut m._wasm_id },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_wasm_bytes",
|m: &PipelineStep| { &m._wasm_bytes },
|m: &mut PipelineStep| { &mut m._wasm_bytes },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_wasm_function",
|m: &PipelineStep| { &m._wasm_function },
|m: &mut PipelineStep| { &mut m._wasm_function },
));
oneofs.push(pipeline_step::Step::generated_oneof_descriptor_data());
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineStep>(
"PipelineStep",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineStep {
const NAME: &'static str = "PipelineStep";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.name = is.read_string()?;
},
18 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.on_true)?;
},
26 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.on_false)?;
},
32 => {
self.dynamic = is.read_bool()?;
},
42 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.on_error)?;
},
8002 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(is.read_message()?));
},
8010 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(is.read_message()?));
},
8018 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(is.read_message()?));
},
8026 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(is.read_message()?));
},
8034 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(is.read_message()?));
},
8042 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::HttpRequest(is.read_message()?));
},
8050 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Kv(is.read_message()?));
},
8058 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::InferSchema(is.read_message()?));
},
8066 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::ValidJson(is.read_message()?));
},
8074 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::SchemaValidation(is.read_message()?));
},
80002 => {
self._wasm_id = ::std::option::Option::Some(is.read_string()?);
},
80010 => {
self._wasm_bytes = ::std::option::Option::Some(is.read_bytes()?);
},
80018 => {
self._wasm_function = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if let Some(v) = self.on_true.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.on_false.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if self.dynamic != false {
my_size += 1 + 1;
}
if let Some(v) = self.on_error.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self._wasm_id.as_ref() {
my_size += ::protobuf::rt::string_size(10000, &v);
}
if let Some(v) = self._wasm_bytes.as_ref() {
my_size += ::protobuf::rt::bytes_size(10001, &v);
}
if let Some(v) = self._wasm_function.as_ref() {
my_size += ::protobuf::rt::string_size(10002, &v);
}
if let ::std::option::Option::Some(ref v) = self.step {
match v {
&pipeline_step::Step::Detective(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Transform(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Encode(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Decode(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Custom(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::HttpRequest(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Kv(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::InferSchema(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::ValidJson(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::SchemaValidation(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if let Some(v) = self.on_true.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
}
if let Some(v) = self.on_false.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
}
if self.dynamic != false {
os.write_bool(4, self.dynamic)?;
}
if let Some(v) = self.on_error.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
}
if let Some(v) = self._wasm_id.as_ref() {
os.write_string(10000, v)?;
}
if let Some(v) = self._wasm_bytes.as_ref() {
os.write_bytes(10001, v)?;
}
if let Some(v) = self._wasm_function.as_ref() {
os.write_string(10002, v)?;
}
if let ::std::option::Option::Some(ref v) = self.step {
match v {
&pipeline_step::Step::Detective(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1000, v, os)?;
},
&pipeline_step::Step::Transform(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1001, v, os)?;
},
&pipeline_step::Step::Encode(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1002, v, os)?;
},
&pipeline_step::Step::Decode(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1003, v, os)?;
},
&pipeline_step::Step::Custom(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1004, v, os)?;
},
&pipeline_step::Step::HttpRequest(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1005, v, os)?;
},
&pipeline_step::Step::Kv(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1006, v, os)?;
},
&pipeline_step::Step::InferSchema(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1007, v, os)?;
},
&pipeline_step::Step::ValidJson(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1008, v, os)?;
},
&pipeline_step::Step::SchemaValidation(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1009, v, os)?;
},
};
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineStep {
PipelineStep::new()
}
fn clear(&mut self) {
self.name.clear();
self.on_true.clear();
self.on_false.clear();
self.dynamic = false;
self.on_error.clear();
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self._wasm_id = ::std::option::Option::None;
self._wasm_bytes = ::std::option::Option::None;
self._wasm_function = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineStep {
static instance: PipelineStep = PipelineStep {
name: ::std::string::String::new(),
on_true: ::protobuf::MessageField::none(),
on_false: ::protobuf::MessageField::none(),
dynamic: false,
on_error: ::protobuf::MessageField::none(),
_wasm_id: ::std::option::Option::None,
_wasm_bytes: ::std::option::Option::None,
_wasm_function: ::std::option::Option::None,
step: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineStep {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineStep").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineStep {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineStep {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod pipeline_step {
#[derive(Clone,PartialEq,Debug)]
#[non_exhaustive]
pub enum Step {
Detective(super::super::sp_steps_detective::DetectiveStep),
Transform(super::super::sp_steps_transform::TransformStep),
Encode(super::super::sp_steps_encode::EncodeStep),
Decode(super::super::sp_steps_decode::DecodeStep),
Custom(super::super::sp_steps_custom::CustomStep),
HttpRequest(super::super::sp_steps_httprequest::HttpRequestStep),
Kv(super::super::sp_steps_kv::KVStep),
InferSchema(super::super::sp_steps_inferschema::InferSchemaStep),
ValidJson(super::super::sp_steps_valid_json::ValidJSONStep),
SchemaValidation(super::super::sp_steps_schema_validation::SchemaValidationStep),
}
impl ::protobuf::Oneof for Step {
}
impl ::protobuf::OneofFull for Step {
fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| <super::PipelineStep as ::protobuf::MessageFull>::descriptor().oneof_by_name("step").unwrap()).clone()
}
}
impl Step {
pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
::protobuf::reflect::GeneratedOneofDescriptorData::new::<Step>("step")
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineConfigs {
pub configs: ::std::vec::Vec<PipelineConfig>,
pub _is_empty: ::std::option::Option<bool>,
pub _created_by: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineConfigs {
fn default() -> &'a PipelineConfigs {
<PipelineConfigs as ::protobuf::Message>::default_instance()
}
}
impl PipelineConfigs {
pub fn new() -> PipelineConfigs {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"configs",
|m: &PipelineConfigs| { &m.configs },
|m: &mut PipelineConfigs| { &mut m.configs },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_is_empty",
|m: &PipelineConfigs| { &m._is_empty },
|m: &mut PipelineConfigs| { &mut m._is_empty },
));
fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
"_created_by",
|m: &PipelineConfigs| { &m._created_by },
|m: &mut PipelineConfigs| { &mut m._created_by },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineConfigs>(
"PipelineConfigs",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineConfigs {
const NAME: &'static str = "PipelineConfigs";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.configs.push(is.read_message()?);
},
8000 => {
self._is_empty = ::std::option::Option::Some(is.read_bool()?);
},
8010 => {
self._created_by = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.configs {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self._is_empty {
my_size += 2 + 1;
}
if let Some(v) = self._created_by.as_ref() {
my_size += ::protobuf::rt::string_size(1001, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.configs {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
if let Some(v) = self._is_empty {
os.write_bool(1000, v)?;
}
if let Some(v) = self._created_by.as_ref() {
os.write_string(1001, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineConfigs {
PipelineConfigs::new()
}
fn clear(&mut self) {
self.configs.clear();
self._is_empty = ::std::option::Option::None;
self._created_by = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineConfigs {
static instance: PipelineConfigs = PipelineConfigs {
configs: ::std::vec::Vec::new(),
_is_empty: ::std::option::Option::None,
_created_by: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineConfigs {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineConfigs").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineConfigs {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineConfigs {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineConfig {
pub id: ::std::string::String,
pub paused: bool,
pub created_at_unix_ts_utc: i64,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineConfig {
fn default() -> &'a PipelineConfig {
<PipelineConfig as ::protobuf::Message>::default_instance()
}
}
impl PipelineConfig {
pub fn new() -> PipelineConfig {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &PipelineConfig| { &m.id },
|m: &mut PipelineConfig| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"paused",
|m: &PipelineConfig| { &m.paused },
|m: &mut PipelineConfig| { &mut m.paused },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"created_at_unix_ts_utc",
|m: &PipelineConfig| { &m.created_at_unix_ts_utc },
|m: &mut PipelineConfig| { &mut m.created_at_unix_ts_utc },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineConfig>(
"PipelineConfig",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineConfig {
const NAME: &'static str = "PipelineConfig";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
16 => {
self.paused = is.read_bool()?;
},
24 => {
self.created_at_unix_ts_utc = is.read_int64()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if self.paused != false {
my_size += 1 + 1;
}
if self.created_at_unix_ts_utc != 0 {
my_size += ::protobuf::rt::int64_size(3, self.created_at_unix_ts_utc);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if self.paused != false {
os.write_bool(2, self.paused)?;
}
if self.created_at_unix_ts_utc != 0 {
os.write_int64(3, self.created_at_unix_ts_utc)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineConfig {
PipelineConfig::new()
}
fn clear(&mut self) {
self.id.clear();
self.paused = false;
self.created_at_unix_ts_utc = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineConfig {
static instance: PipelineConfig = PipelineConfig {
id: ::std::string::String::new(),
paused: false,
created_at_unix_ts_utc: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineConfig {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineConfig").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineConfig {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum PipelineDataFormat {
PIPELINE_DATA_FORMAT_UNSET = 0,
PIPELINE_DATA_FORMAT_JSON = 1,
PIPELINE_DATA_FORMAT_PLAINTEXT = 2,
}
impl ::protobuf::Enum for PipelineDataFormat {
const NAME: &'static str = "PipelineDataFormat";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<PipelineDataFormat> {
match value {
0 => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET),
1 => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_JSON),
2 => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_PLAINTEXT),
_ => ::std::option::Option::None
}
}
fn from_str(str: &str) -> ::std::option::Option<PipelineDataFormat> {
match str {
"PIPELINE_DATA_FORMAT_UNSET" => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET),
"PIPELINE_DATA_FORMAT_JSON" => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_JSON),
"PIPELINE_DATA_FORMAT_PLAINTEXT" => ::std::option::Option::Some(PipelineDataFormat::PIPELINE_DATA_FORMAT_PLAINTEXT),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [PipelineDataFormat] = &[
PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET,
PipelineDataFormat::PIPELINE_DATA_FORMAT_JSON,
PipelineDataFormat::PIPELINE_DATA_FORMAT_PLAINTEXT,
];
}
impl ::protobuf::EnumFull for PipelineDataFormat {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().enum_by_package_relative_name("PipelineDataFormat").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for PipelineDataFormat {
fn default() -> Self {
PipelineDataFormat::PIPELINE_DATA_FORMAT_UNSET
}
}
impl PipelineDataFormat {
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<PipelineDataFormat>("PipelineDataFormat")
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum AbortCondition {
ABORT_CONDITION_UNSET = 0,
ABORT_CONDITION_ABORT_CURRENT = 1,
ABORT_CONDITION_ABORT_ALL = 2,
}
impl ::protobuf::Enum for AbortCondition {
const NAME: &'static str = "AbortCondition";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<AbortCondition> {
match value {
0 => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_UNSET),
1 => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_ABORT_CURRENT),
2 => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_ABORT_ALL),
_ => ::std::option::Option::None
}
}
fn from_str(str: &str) -> ::std::option::Option<AbortCondition> {
match str {
"ABORT_CONDITION_UNSET" => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_UNSET),
"ABORT_CONDITION_ABORT_CURRENT" => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_ABORT_CURRENT),
"ABORT_CONDITION_ABORT_ALL" => ::std::option::Option::Some(AbortCondition::ABORT_CONDITION_ABORT_ALL),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [AbortCondition] = &[
AbortCondition::ABORT_CONDITION_UNSET,
AbortCondition::ABORT_CONDITION_ABORT_CURRENT,
AbortCondition::ABORT_CONDITION_ABORT_ALL,
];
}
impl ::protobuf::EnumFull for AbortCondition {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().enum_by_package_relative_name("AbortCondition").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for AbortCondition {
fn default() -> Self {
AbortCondition::ABORT_CONDITION_UNSET
}
}
impl AbortCondition {
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<AbortCondition>("AbortCondition")
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x11sp_pipeline.proto\x12\x06protos\x1a\x0fsp_notify.proto\x1a\x1bstep\
s/sp_steps_custom.proto\x1a\x1bsteps/sp_steps_decode.proto\x1a\x1esteps/\
sp_steps_detective.proto\x1a\x1bsteps/sp_steps_encode.proto\x1a\x20steps\
/sp_steps_httprequest.proto\x1a\x20steps/sp_steps_inferschema.proto\x1a\
\x17steps/sp_steps_kv.proto\x1a&steps/sp_steps_schema_validation.proto\
\x1a\x1esteps/sp_steps_transform.proto\x1a\x1fsteps/sp_steps_valid_json.\
proto\"\x84\x05\n\x08Pipeline\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\
\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12*\n\x05steps\x18\x03\
\x20\x03(\x0b2\x14.protos.PipelineStepR\x05steps\x12R\n\x15_notification\
_configs\x18\x04\x20\x03(\x0b2\x1a.protos.NotificationConfigR\x13Notific\
ationConfigsB\x02\x18\x01\x12;\n\x0bdata_format\x18\x05\x20\x01(\x0e2\
\x1a.protos.PipelineDataFormatR\ndataFormat\x12\x1d\n\x07_paused\x18\xe8\
\x07\x20\x01(\x08H\0R\x06Paused\x88\x01\x01\x12'\n\x0c_description\x18\
\xe9\x07\x20\x01(\tH\x01R\x0bDescription\x88\x01\x01\x12\x1f\n\x08_versi\
on\x18\xea\x07\x20\x01(\tH\x02R\x07Version\x88\x01\x01\x12\x17\n\x04_url\
\x18\xeb\x07\x20\x01(\tH\x03R\x03Url\x88\x01\x01\x129\n\x17_created_at_u\
nix_ts_utc\x18\xec\x07\x20\x01(\x03H\x04R\x12CreatedAtUnixTsUtc\x88\x01\
\x01\x129\n\x17_updated_at_unix_ts_utc\x18\xed\x07\x20\x01(\x03H\x05R\
\x12UpdatedAtUnixTsUtc\x88\x01\x01\x12$\n\x0b_created_by\x18\xee\x07\x20\
\x01(\tH\x06R\tCreatedBy\x88\x01\x01B\n\n\x08X_pausedB\x0f\n\rX_descript\
ionB\x0b\n\tX_versionB\x07\n\x05X_urlB\x1a\n\x18X_created_at_unix_ts_utc\
B\x1a\n\x18X_updated_at_unix_ts_utcB\x0e\n\x0cX_created_by\"\xaf\x02\n\
\x16PipelineStepConditions\x12,\n\x05abort\x18\x01\x20\x01(\x0e2\x16.pro\
tos.AbortConditionR\x05abort\x12\x1a\n\x06notify\x18\x02\x20\x01(\x08R\
\x06notifyB\x02\x18\x01\x12H\n\x08metadata\x18\x03\x20\x03(\x0b2,.protos\
.PipelineStepConditions.MetadataEntryR\x08metadata\x12D\n\x0cnotificatio\
n\x18\x04\x20\x01(\x0b2\x20.protos.PipelineStepNotificationR\x0cnotifica\
tion\x1a;\n\rMetadataEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\
\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"\xb8\x02\n\
\x18PipelineStepNotification\x126\n\x17notification_config_ids\x18\x01\
\x20\x03(\tR\x15notificationConfigIds\x12O\n\x0cpayload_type\x18\x02\x20\
\x01(\x0e2,.protos.PipelineStepNotification.PayloadTypeR\x0bpayloadType\
\x12\x14\n\x05paths\x18\x03\x20\x03(\tR\x05paths\"}\n\x0bPayloadType\x12\
\x16\n\x12PAYLOAD_TYPE_UNSET\x10\0\x12\x18\n\x14PAYLOAD_TYPE_EXCLUDE\x10\
\x01\x12\x1d\n\x19PAYLOAD_TYPE_FULL_PAYLOAD\x10\x02\x12\x1d\n\x19PAYLOAD\
_TYPE_SELECT_PATHS\x10\x03\"\xf6\x07\n\x0cPipelineStep\x12\x12\n\x04name\
\x18\x01\x20\x01(\tR\x04name\x127\n\x07on_true\x18\x02\x20\x01(\x0b2\x1e\
.protos.PipelineStepConditionsR\x06onTrue\x129\n\x08on_false\x18\x03\x20\
\x01(\x0b2\x1e.protos.PipelineStepConditionsR\x07onFalse\x12\x18\n\x07dy\
namic\x18\x04\x20\x01(\x08R\x07dynamic\x129\n\x08on_error\x18\x05\x20\
\x01(\x0b2\x1e.protos.PipelineStepConditionsR\x07onError\x12<\n\tdetecti\
ve\x18\xe8\x07\x20\x01(\x0b2\x1b.protos.steps.DetectiveStepH\0R\tdetecti\
ve\x12<\n\ttransform\x18\xe9\x07\x20\x01(\x0b2\x1b.protos.steps.Transfor\
mStepH\0R\ttransform\x123\n\x06encode\x18\xea\x07\x20\x01(\x0b2\x18.prot\
os.steps.EncodeStepH\0R\x06encode\x123\n\x06decode\x18\xeb\x07\x20\x01(\
\x0b2\x18.protos.steps.DecodeStepH\0R\x06decode\x123\n\x06custom\x18\xec\
\x07\x20\x01(\x0b2\x18.protos.steps.CustomStepH\0R\x06custom\x12C\n\x0ch\
ttp_request\x18\xed\x07\x20\x01(\x0b2\x1d.protos.steps.HttpRequestStepH\
\0R\x0bhttpRequest\x12'\n\x02kv\x18\xee\x07\x20\x01(\x0b2\x14.protos.ste\
ps.KVStepH\0R\x02kv\x12C\n\x0cinfer_schema\x18\xef\x07\x20\x01(\x0b2\x1d\
.protos.steps.InferSchemaStepH\0R\x0binferSchema\x12=\n\nvalid_json\x18\
\xf0\x07\x20\x01(\x0b2\x1b.protos.steps.ValidJSONStepH\0R\tvalidJson\x12\
R\n\x11schema_validation\x18\xf1\x07\x20\x01(\x0b2\".protos.steps.Schema\
ValidationStepH\0R\x10schemaValidation\x12\x1e\n\x08_wasm_id\x18\x90N\
\x20\x01(\tH\x01R\x06WasmId\x88\x01\x01\x12$\n\x0b_wasm_bytes\x18\x91N\
\x20\x01(\x0cH\x02R\tWasmBytes\x88\x01\x01\x12*\n\x0e_wasm_function\x18\
\x92N\x20\x01(\tH\x03R\x0cWasmFunction\x88\x01\x01B\x06\n\x04stepB\x0b\n\
\tX_wasm_idB\x0e\n\x0cX_wasm_bytesB\x11\n\x0fX_wasm_function\"\xa9\x01\n\
\x0fPipelineConfigs\x120\n\x07configs\x18\x01\x20\x03(\x0b2\x16.protos.P\
ipelineConfigR\x07configs\x12\x20\n\t_is_empty\x18\xe8\x07\x20\x01(\x08H\
\0R\x07IsEmpty\x88\x01\x01\x12$\n\x0b_created_by\x18\xe9\x07\x20\x01(\tH\
\x01R\tCreatedBy\x88\x01\x01B\x0c\n\nX_is_emptyB\x0e\n\x0cX_created_by\"\
l\n\x0ePipelineConfig\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\x16\
\n\x06paused\x18\x02\x20\x01(\x08R\x06paused\x122\n\x16created_at_unix_t\
s_utc\x18\x03\x20\x01(\x03R\x12createdAtUnixTsUtc*w\n\x12PipelineDataFor\
mat\x12\x1e\n\x1aPIPELINE_DATA_FORMAT_UNSET\x10\0\x12\x1d\n\x19PIPELINE_\
DATA_FORMAT_JSON\x10\x01\x12\"\n\x1ePIPELINE_DATA_FORMAT_PLAINTEXT\x10\
\x02*m\n\x0eAbortCondition\x12\x19\n\x15ABORT_CONDITION_UNSET\x10\0\x12!\
\n\x1dABORT_CONDITION_ABORT_CURRENT\x10\x01\x12\x1d\n\x19ABORT_CONDITION\
_ABORT_ALL\x10\x02BPZ:github.com/streamdal/streamdal/libs/protos/build/g\
o/protos\xea\x02\x11Streamdal::ProtosJ\xcf;\n\x07\x12\x05\0\0\xbf\x01\
\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x0f\n\
\t\n\x02\x03\0\x12\x03\x04\0\x19\n\t\n\x02\x03\x01\x12\x03\x05\0%\n\t\n\
\x02\x03\x02\x12\x03\x06\0%\n\t\n\x02\x03\x03\x12\x03\x07\0(\n\t\n\x02\
\x03\x04\x12\x03\x08\0%\n\t\n\x02\x03\x05\x12\x03\t\0*\n\t\n\x02\x03\x06\
\x12\x03\n\0*\n\t\n\x02\x03\x07\x12\x03\x0b\0!\n\t\n\x02\x03\x08\x12\x03\
\x0c\00\n\t\n\x02\x03\t\x12\x03\r\0(\n\t\n\x02\x03\n\x12\x03\x0e\0)\n\
\x08\n\x01\x08\x12\x03\x10\0Q\n\t\n\x02\x08\x0b\x12\x03\x10\0Q\n\x08\n\
\x01\x08\x12\x03\x11\0*\n\t\n\x02\x08-\x12\x03\x11\0*\n\n\n\x02\x05\0\
\x12\x04\x13\0\x17\x01\n\n\n\x03\x05\0\x01\x12\x03\x13\x05\x17\n\x0b\n\
\x04\x05\0\x02\0\x12\x03\x14\x02!\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\
\x14\x02\x1c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x14\x1f\x20\n\x0b\n\x04\
\x05\0\x02\x01\x12\x03\x15\x02\x20\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\
\x15\x02\x1b\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x15\x1e\x1f\n\x0b\n\
\x04\x05\0\x02\x02\x12\x03\x16\x02%\n\x0c\n\x05\x05\0\x02\x02\x01\x12\
\x03\x16\x02\x20\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\x16#$\n\xc8\x01\n\
\x02\x04\0\x12\x04\x1c\0>\x01\x1a\xbb\x01\x20Pipeline\x20is\x20a\x20stru\
cture\x20that\x20holds\x20one\x20or\x20more\x20pipeline\x20steps.\x20Thi\
s\x20structure\n\x20is\x20intended\x20to\x20be\x20immutable;\x20clients\
\x20are\x20expected\x20to\x20generate\x20WASMRequest's\n\x20that\x20cont\
ain\x20a\x20pipeline\x20step.\n\n\n\n\x03\x04\0\x01\x12\x03\x1c\x08\x10\
\n\xa9\x01\n\x04\x04\0\x02\0\x12\x03\x1f\x02\x10\x1a\x9b\x01\x20If\x20le\
ft\x20blank,\x20the\x20server\x20will\x20generate\x20a\x20unique\x20ID.\
\x20If\x20one\x20is\x20provided,\n\x20the\x20server\x20will\x20check\x20\
if\x20that\x20is\x20ID\x20is\x20already\x20in\x20use\x20when\x20creating\
\x20a\x20pipeline.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x1f\x02\x08\n\
\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x1f\t\x0b\n\x0c\n\x05\x04\0\x02\0\x03\
\x12\x03\x1f\x0e\x0f\n-\n\x04\x04\0\x02\x01\x12\x03\"\x02\x12\x1a\x20\
\x20Friendly\x20name\x20for\x20the\x20pipeline\n\n\x0c\n\x05\x04\0\x02\
\x01\x05\x12\x03\"\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\"\t\r\n\
\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\"\x10\x11\n+\n\x04\x04\0\x02\x02\
\x12\x03%\x02\"\x1a\x1e\x20One\x20or\x20more\x20steps\x20to\x20execute\n\
\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03%\x02\n\n\x0c\n\x05\x04\0\x02\x02\
\x06\x12\x03%\x0b\x17\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03%\x18\x1d\n\
\x0c\n\x05\x04\0\x02\x02\x03\x12\x03%\x20!\n\xd3\x01\n\x04\x04\0\x02\x03\
\x12\x03+\x02Q\x1a\x8e\x01\x20Notification\x20configs\x20for\x20this\x20\
pipeline.\x20Only\x20filled\x20out\x20in\x20external\x20API\x20responses\
\n\x20This\x20is\x20deprecated\x20and\x20the\x20data\x20has\x20moved\x20\
to\x20PipelineStep\n\"5\x20protolint:disable:this\x20FIELD_NAMES_LOWER_S\
NAKE_CASE\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03+\x02\n\n\x0c\n\x05\x04\
\0\x02\x03\x06\x12\x03+\x0b$\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03+%:\n\
\x0c\n\x05\x04\0\x02\x03\x03\x12\x03+=>\n\x0c\n\x05\x04\0\x02\x03\x08\
\x12\x03+?P\n\r\n\x06\x04\0\x02\x03\x08\x03\x12\x03+@O\n\x0b\n\x04\x04\0\
\x02\x04\x12\x03-\x02%\n\x0c\n\x05\x04\0\x02\x04\x06\x12\x03-\x02\x14\n\
\x0c\n\x05\x04\0\x02\x04\x01\x12\x03-\x15\x20\n\x0c\n\x05\x04\0\x02\x04\
\x03\x12\x03-#$\n\x91\x01\n\x04\x04\0\x02\x05\x12\x030\x02\x1f\x1aM\x20I\
ndicates\x20whether\x20the\x20pipeline\x20is\x20paused\x20or\x20not.\x20\
Used\x20internally\x20by\x20server.\n\"5\x20protolint:disable:this\x20FI\
ELD_NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x030\x02\
\n\n\x0c\n\x05\x04\0\x02\x05\x05\x12\x030\x0b\x0f\n\x0c\n\x05\x04\0\x02\
\x05\x01\x12\x030\x10\x17\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x030\x1a\x1e\
\nB\n\x04\x04\0\x02\x06\x12\x032\x02'\"5\x20protolint:disable:this\x20FI\
ELD_NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\x02\x06\x04\x12\x032\x02\
\n\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x032\x0c\x12\n\x0c\n\x05\x04\0\x02\
\x06\x01\x12\x032\x13\x1f\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x032\"&\nB\n\
\x04\x04\0\x02\x07\x12\x034\x02\"\"5\x20protolint:disable:this\x20FIELD_\
NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\x02\x07\x04\x12\x034\x02\n\n\
\x0c\n\x05\x04\0\x02\x07\x05\x12\x034\x0b\x11\n\x0c\n\x05\x04\0\x02\x07\
\x01\x12\x034\x12\x1a\n\x0c\n\x05\x04\0\x02\x07\x03\x12\x034\x1d!\nB\n\
\x04\x04\0\x02\x08\x12\x036\x02\x1e\"5\x20protolint:disable:this\x20FIEL\
D_NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\x02\x08\x04\x12\x036\x02\n\
\n\x0c\n\x05\x04\0\x02\x08\x05\x12\x036\x0b\x11\n\x0c\n\x05\x04\0\x02\
\x08\x01\x12\x036\x12\x16\n\x0c\n\x05\x04\0\x02\x08\x03\x12\x036\x19\x1d\
\nB\n\x04\x04\0\x02\t\x12\x038\x020\"5\x20protolint:disable:this\x20FIEL\
D_NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\x02\t\x04\x12\x038\x02\n\n\
\x0c\n\x05\x04\0\x02\t\x05\x12\x038\x0b\x10\n\x0c\n\x05\x04\0\x02\t\x01\
\x12\x038\x11(\n\x0c\n\x05\x04\0\x02\t\x03\x12\x038+/\nB\n\x04\x04\0\x02\
\n\x12\x03:\x020\"5\x20protolint:disable:this\x20FIELD_NAMES_LOWER_SNAKE\
_CASE\n\n\x0c\n\x05\x04\0\x02\n\x04\x12\x03:\x02\n\n\x0c\n\x05\x04\0\x02\
\n\x05\x12\x03:\x0b\x10\n\x0c\n\x05\x04\0\x02\n\x01\x12\x03:\x11(\n\x0c\
\n\x05\x04\0\x02\n\x03\x12\x03:+/\n\x97\x01\n\x04\x04\0\x02\x0b\x12\x03=\
\x02%\x1aS\x20Used\x20internally\x20by\x20server\x20and\x20k8s\x20operat\
or\x20to\x20determine\x20who\x20manages\x20this\x20resource\n\"5\x20prot\
olint:disable:this\x20FIELD_NAMES_LOWER_SNAKE_CASE\n\n\x0c\n\x05\x04\0\
\x02\x0b\x04\x12\x03=\x02\n\n\x0c\n\x05\x04\0\x02\x0b\x05\x12\x03=\x0b\
\x11\n\x0c\n\x05\x04\0\x02\x0b\x01\x12\x03=\x12\x1d\n\x0c\n\x05\x04\0\
\x02\x0b\x03\x12\x03=\x20$\nA\n\x02\x05\x01\x12\x04A\0E\x01\x1a5\x20Defi\
nes\x20the\x20ways\x20in\x20which\x20a\x20pipeline\x20can\x20be\x20abort\
ed\n\n\n\n\x03\x05\x01\x01\x12\x03A\x05\x13\n\x0b\n\x04\x05\x01\x02\0\
\x12\x03B\x02\x1c\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03B\x02\x17\n\x0c\n\
\x05\x05\x01\x02\0\x02\x12\x03B\x1a\x1b\n\x0b\n\x04\x05\x01\x02\x01\x12\
\x03C\x02$\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03C\x02\x1f\n\x0c\n\x05\
\x05\x01\x02\x01\x02\x12\x03C\"#\n\x0b\n\x04\x05\x01\x02\x02\x12\x03D\
\x02\x20\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03D\x02\x1b\n\x0c\n\x05\
\x05\x01\x02\x02\x02\x12\x03D\x1e\x1f\n\xd0\x01\n\x02\x04\x01\x12\x04K\0\
U\x01\x1a\xc3\x01\x20Conditions\x20define\x20how\x20the\x20SDK\x20should\
\x20handle\x20a\x20Wasm\x20response\x20in\x20a\x20step.\n\x20Should\x20i\
t\x20continue\x20executing\x20the\x20pipeline,\x20should\x20it\x20abort,\
\x20should\x20it\x20notify\n\x20and\x20on_error.\n\x20TODO:\x20de-plural\
ize\x20this\x20name\n\n\n\n\x03\x04\x01\x01\x12\x03K\x08\x1e\n)\n\x04\
\x04\x01\x02\0\x12\x03M\x02\x1b\x1a\x1c\x20Should\x20we\x20abort\x20exec\
ution?\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03M\x02\x10\n\x0c\n\x05\x04\
\x01\x02\0\x01\x12\x03M\x11\x16\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03M\
\x19\x1a\n\x0b\n\x04\x04\x01\x02\x01\x12\x03O\x02$\n\x0c\n\x05\x04\x01\
\x02\x01\x05\x12\x03O\x02\x06\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03O\
\x07\r\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03O\x10\x11\n\x0c\n\x05\x04\
\x01\x02\x01\x08\x12\x03O\x12#\n\r\n\x06\x04\x01\x02\x01\x08\x03\x12\x03\
O\x13\"\nW\n\x04\x04\x01\x02\x02\x12\x03R\x02#\x1aJ\x20Should\x20we\x20i\
nclude\x20additional\x20metadata\x20that\x20SDK\x20should\x20pass\x20bac\
k\x20to\x20user?\n\n\x0c\n\x05\x04\x01\x02\x02\x06\x12\x03R\x02\x15\n\
\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03R\x16\x1e\n\x0c\n\x05\x04\x01\x02\
\x02\x03\x12\x03R!\"\n\x0b\n\x04\x04\x01\x02\x03\x12\x03T\x02,\n\x0c\n\
\x05\x04\x01\x02\x03\x06\x12\x03T\x02\x1a\n\x0c\n\x05\x04\x01\x02\x03\
\x01\x12\x03T\x1b'\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03T*+\n\n\n\x02\
\x04\x02\x12\x04X\0r\x01\n\n\n\x03\x04\x02\x01\x12\x03X\x08\x20\n\x0c\n\
\x04\x04\x02\x04\0\x12\x04Y\x02f\x03\n\x0c\n\x05\x04\x02\x04\0\x01\x12\
\x03Y\x07\x12\n;\n\x06\x04\x02\x04\0\x02\0\x12\x03[\x04\x1b\x1a,\x20Same\
\x20functionality\x20as\x20PAYLOAD_TYPE_EXCLUDE\n\n\x0e\n\x07\x04\x02\
\x04\0\x02\0\x01\x12\x03[\x04\x16\n\x0e\n\x07\x04\x02\x04\0\x02\0\x02\
\x12\x03[\x19\x1a\nB\n\x06\x04\x02\x04\0\x02\x01\x12\x03^\x04\x1d\x1a3\
\x20Default.\x20No\x20payload\x20data\x20included\x20in\x20notification\
\n\n\x0e\n\x07\x04\x02\x04\0\x02\x01\x01\x12\x03^\x04\x18\n\x0e\n\x07\
\x04\x02\x04\0\x02\x01\x02\x12\x03^\x1b\x1c\n@\n\x06\x04\x02\x04\0\x02\
\x02\x12\x03a\x04\"\x1a1\x20Entire\x20payload\x20content\x20included\x20\
in\x20notification\n\n\x0e\n\x07\x04\x02\x04\0\x02\x02\x01\x12\x03a\x04\
\x1d\n\x0e\n\x07\x04\x02\x04\0\x02\x02\x02\x12\x03a\x20!\n\x8a\x01\n\x06\
\x04\x02\x04\0\x02\x03\x12\x03e\x04\"\x1a{\x20Only\x20specified\x20paths\
\x20of\x20payload\x20content\x20included\x20in\x20notification\n\x20Only\
\x20works\x20on\x20JSON.\x20Plaintext\x20payloads\x20will\x20be\x20ignor\
ed.\n\n\x0e\n\x07\x04\x02\x04\0\x02\x03\x01\x12\x03e\x04\x1d\n\x0e\n\x07\
\x04\x02\x04\0\x02\x03\x02\x12\x03e\x20!\n\xd0\x01\n\x04\x04\x02\x02\0\
\x12\x03k\x02.\x1a\xc2\x01\x20The\x20UUIDs\x20of\x20the\x20notification\
\x20config\x20to\x20use\n\x20This\x20is\x20kept\x20separate\x20to\x20avo\
id\x20having\x20to\x20configure\x20slack/email\x20settings\n\x20every\
\x20time\x20and\x20also\x20because\x20that\x20config\x20info\x20is\x20se\
nsitive\x20and\x20is\x20encrypted\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\
\x03k\x02\n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03k\x0b\x11\n\x0c\n\x05\
\x04\x02\x02\0\x01\x12\x03k\x12)\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03k,\
-\n\x0b\n\x04\x04\x02\x02\x01\x12\x03m\x02\x1f\n\x0c\n\x05\x04\x02\x02\
\x01\x06\x12\x03m\x02\r\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03m\x0e\x1a\
\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03m\x1d\x1e\ny\n\x04\x04\x02\x02\
\x02\x12\x03q\x02\x1c\x1al\x20If\x20type\x20==\x20paths,\x20then\x20we\
\x20will\x20look\x20here\x20for\x20a\x20list\x20of\x20json\x20paths\x20t\
o\x20include\n\x20in\x20the\x20notification\x20payload.\n\n\x0c\n\x05\
\x04\x02\x02\x02\x04\x12\x03q\x02\n\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\
\x03q\x0b\x11\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03q\x12\x17\n\x0c\n\
\x05\x04\x02\x02\x02\x03\x12\x03q\x1a\x1b\n>\n\x02\x04\x03\x12\x05u\0\
\xa5\x01\x01\x1a1\x20A\x20pipeline\x20step\x20is\x20a\x20single\x20step\
\x20in\x20a\x20pipeline.\n\n\n\n\x03\x04\x03\x01\x12\x03u\x08\x14\n)\n\
\x04\x04\x03\x02\0\x12\x03w\x02\x12\x1a\x1c\x20Friendly\x20name\x20for\
\x20the\x20step\n\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03w\x02\x08\n\x0c\n\
\x05\x04\x03\x02\0\x01\x12\x03w\t\r\n\x0c\n\x05\x04\x03\x02\0\x03\x12\
\x03w\x10\x11\n[\n\x04\x04\x03\x02\x01\x12\x03z\x02%\x1aN\x20SDKs\x20sho\
uld\x20read\x20this\x20when\x20Wasm\x20returns\x20'true'\x20to\x20determ\
ine\x20what\x20to\x20do\x20next.\n\n\x0c\n\x05\x04\x03\x02\x01\x06\x12\
\x03z\x02\x18\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03z\x19\x20\n\x0c\n\
\x05\x04\x03\x02\x01\x03\x12\x03z#$\n\\\n\x04\x04\x03\x02\x02\x12\x03}\
\x02&\x1aO\x20SDKs\x20should\x20read\x20this\x20when\x20Wasm\x20returns\
\x20'false'\x20to\x20determine\x20what\x20to\x20do\x20next.\n\n\x0c\n\
\x05\x04\x03\x02\x02\x06\x12\x03}\x02\x18\n\x0c\n\x05\x04\x03\x02\x02\
\x01\x12\x03}\x19!\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03}$%\n_\n\x04\
\x04\x03\x02\x03\x12\x04\x80\x01\x02\x13\x1aQ\x20Indicates\x20whether\
\x20to\x20use\x20the\x20results\x20from\x20a\x20previous\x20step\x20as\
\x20input\x20to\x20this\x20step\n\n\r\n\x05\x04\x03\x02\x03\x05\x12\x04\
\x80\x01\x02\x06\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\x80\x01\x07\x0e\n\
\r\n\x05\x04\x03\x02\x03\x03\x12\x04\x80\x01\x11\x12\n]\n\x04\x04\x03\
\x02\x04\x12\x04\x83\x01\x02&\x1aO\x20SDKs\x20should\x20read\x20this\x20\
when\x20Wasm\x20returns\x20'error'\x20to\x20determine\x20what\x20to\x20d\
o\x20next.\n\n\r\n\x05\x04\x03\x02\x04\x06\x12\x04\x83\x01\x02\x18\n\r\n\
\x05\x04\x03\x02\x04\x01\x12\x04\x83\x01\x19!\n\r\n\x05\x04\x03\x02\x04\
\x03\x12\x04\x83\x01$%\n\x0e\n\x04\x04\x03\x08\0\x12\x06\x85\x01\x02\x93\
\x01\x03\n\r\n\x05\x04\x03\x08\0\x01\x12\x04\x85\x01\x08\x0c\n\x0c\n\x04\
\x04\x03\x02\x05\x12\x04\x86\x01\x04)\n\r\n\x05\x04\x03\x02\x05\x06\x12\
\x04\x86\x01\x04\x17\n\r\n\x05\x04\x03\x02\x05\x01\x12\x04\x86\x01\x18!\
\n\r\n\x05\x04\x03\x02\x05\x03\x12\x04\x86\x01$(\n\x0c\n\x04\x04\x03\x02\
\x06\x12\x04\x87\x01\x04)\n\r\n\x05\x04\x03\x02\x06\x06\x12\x04\x87\x01\
\x04\x17\n\r\n\x05\x04\x03\x02\x06\x01\x12\x04\x87\x01\x18!\n\r\n\x05\
\x04\x03\x02\x06\x03\x12\x04\x87\x01$(\n\x0c\n\x04\x04\x03\x02\x07\x12\
\x04\x88\x01\x04#\n\r\n\x05\x04\x03\x02\x07\x06\x12\x04\x88\x01\x04\x14\
\n\r\n\x05\x04\x03\x02\x07\x01\x12\x04\x88\x01\x15\x1b\n\r\n\x05\x04\x03\
\x02\x07\x03\x12\x04\x88\x01\x1e\"\n\x0c\n\x04\x04\x03\x02\x08\x12\x04\
\x89\x01\x04#\n\r\n\x05\x04\x03\x02\x08\x06\x12\x04\x89\x01\x04\x14\n\r\
\n\x05\x04\x03\x02\x08\x01\x12\x04\x89\x01\x15\x1b\n\r\n\x05\x04\x03\x02\
\x08\x03\x12\x04\x89\x01\x1e\"\n,\n\x04\x04\x03\x02\t\x12\x04\x8c\x01\
\x04#\x1a\x1e\x20If\x20set,\x20_wasm_id\x20MUST\x20be\x20set\n\n\r\n\x05\
\x04\x03\x02\t\x06\x12\x04\x8c\x01\x04\x14\n\r\n\x05\x04\x03\x02\t\x01\
\x12\x04\x8c\x01\x15\x1b\n\r\n\x05\x04\x03\x02\t\x03\x12\x04\x8c\x01\x1e\
\"\n\x0c\n\x04\x04\x03\x02\n\x12\x04\x8e\x01\x04.\n\r\n\x05\x04\x03\x02\
\n\x06\x12\x04\x8e\x01\x04\x19\n\r\n\x05\x04\x03\x02\n\x01\x12\x04\x8e\
\x01\x1a&\n\r\n\x05\x04\x03\x02\n\x03\x12\x04\x8e\x01)-\n\x0c\n\x04\x04\
\x03\x02\x0b\x12\x04\x8f\x01\x04\x1b\n\r\n\x05\x04\x03\x02\x0b\x06\x12\
\x04\x8f\x01\x04\x10\n\r\n\x05\x04\x03\x02\x0b\x01\x12\x04\x8f\x01\x11\
\x13\n\r\n\x05\x04\x03\x02\x0b\x03\x12\x04\x8f\x01\x16\x1a\n\x0c\n\x04\
\x04\x03\x02\x0c\x12\x04\x90\x01\x04.\n\r\n\x05\x04\x03\x02\x0c\x06\x12\
\x04\x90\x01\x04\x19\n\r\n\x05\x04\x03\x02\x0c\x01\x12\x04\x90\x01\x1a&\
\n\r\n\x05\x04\x03\x02\x0c\x03\x12\x04\x90\x01)-\n\x0c\n\x04\x04\x03\x02\
\r\x12\x04\x91\x01\x04*\n\r\n\x05\x04\x03\x02\r\x06\x12\x04\x91\x01\x04\
\x17\n\r\n\x05\x04\x03\x02\r\x01\x12\x04\x91\x01\x18\"\n\r\n\x05\x04\x03\
\x02\r\x03\x12\x04\x91\x01%)\n\x0c\n\x04\x04\x03\x02\x0e\x12\x04\x92\x01\
\x048\n\r\n\x05\x04\x03\x02\x0e\x06\x12\x04\x92\x01\x04\x1e\n\r\n\x05\
\x04\x03\x02\x0e\x01\x12\x04\x92\x01\x1f0\n\r\n\x05\x04\x03\x02\x0e\x03\
\x12\x04\x92\x0137\n\xe9\x04\n\x04\x04\x03\x02\x0f\x12\x04\x9e\x01\x02#\
\x1a)\x20Set\x20by\x20server\x20UNLESS\x20step\x20is\x20CustomStep\n\"5\
\x20protolint:disable:this\x20FIELD_NAMES_LOWER_SNAKE_CASE\n2\xf8\x03///\
////////////////////////////////////////////////////////////////////\n\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20//\n\x20\x20\
\x20\x20_wasm_*\x20fields\x20only\x20need\x20to\x20be\x20set\x20IF\x20th\
e\x20step\x20is\x20CustomStep.\x20\x20\x20\x20//\n\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20//\n\x20For\x20all\x20other\x20s\
teps,\x20the\x20server\x20will\x20fill\x20these\x20out\x20automatically.\
\x20\x20//\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
//\n////////////////////////////////////////////////////////////////////\
///\n\n\r\n\x05\x04\x03\x02\x0f\x04\x12\x04\x9e\x01\x02\n\n\r\n\x05\x04\
\x03\x02\x0f\x05\x12\x04\x9e\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x0f\x01\
\x12\x04\x9e\x01\x12\x1a\n\r\n\x05\x04\x03\x02\x0f\x03\x12\x04\x9e\x01\
\x1d\"\nT\n\x04\x04\x03\x02\x10\x12\x04\xa1\x01\x02%\x1a\x0f\x20Set\x20b\
y\x20server\n\"5\x20protolint:disable:this\x20FIELD_NAMES_LOWER_SNAKE_CA\
SE\n\n\r\n\x05\x04\x03\x02\x10\x04\x12\x04\xa1\x01\x02\n\n\r\n\x05\x04\
\x03\x02\x10\x05\x12\x04\xa1\x01\x0b\x10\n\r\n\x05\x04\x03\x02\x10\x01\
\x12\x04\xa1\x01\x11\x1c\n\r\n\x05\x04\x03\x02\x10\x03\x12\x04\xa1\x01\
\x1f$\nT\n\x04\x04\x03\x02\x11\x12\x04\xa4\x01\x02)\x1a\x0f\x20Set\x20by\
\x20server\n\"5\x20protolint:disable:this\x20FIELD_NAMES_LOWER_SNAKE_CAS\
E\n\n\r\n\x05\x04\x03\x02\x11\x04\x12\x04\xa4\x01\x02\n\n\r\n\x05\x04\
\x03\x02\x11\x05\x12\x04\xa4\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x11\x01\
\x12\x04\xa4\x01\x12\x20\n\r\n\x05\x04\x03\x02\x11\x03\x12\x04\xa4\x01#(\
\n\x8a\x01\n\x02\x04\x04\x12\x06\xa9\x01\0\xb7\x01\x01\x1a|\x20PipelineC\
onfigs\x20is\x20stored\x20encoded\x20in\x20redis:streamdal_audience:$aud\
Str;\x20it\x20is\n\x20also\x20used\x20in\x20external.GetAllResponse:conf\
ig.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xa9\x01\x08\x17\n\x0c\n\x04\x04\
\x04\x02\0\x12\x04\xaa\x01\x02&\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\xaa\
\x01\x02\n\n\r\n\x05\x04\x04\x02\0\x06\x12\x04\xaa\x01\x0b\x19\n\r\n\x05\
\x04\x04\x02\0\x01\x12\x04\xaa\x01\x1a!\n\r\n\x05\x04\x04\x02\0\x03\x12\
\x04\xaa\x01$%\n\xf1\x02\n\x04\x04\x04\x02\x01\x12\x04\xb3\x01\x02!\x1a\
\xab\x02\x20!!!!!!!!\x20IMPORTANT\x20!!!!!!!!!!\n\n\x20For\x20internal\
\x20use\x20only\x20in\x20server.\x20We\x20need\x20this\x20because\x20mar\
shalling/encoding\n\x20an\x20empty\x20protobuf\x20results\x20in\x20nil.\
\x20If\x20someone\x20does\x20a\x20SetPipelines()\x20with\n\x20empty\x20p\
ipeline\x20IDs\x20-\x20we\x20will\x20set\x20this,\x20so\x20that\x20the\
\x20encoded\x20protobuf\x20gets\n\x20written\x20as\x20the\x20actual\x20o\
bject\x20and\x20not\x20nil.\n\n\"5\x20protolint:disable:this\x20FIELD_NA\
MES_LOWER_SNAKE_CASE\n\n\r\n\x05\x04\x04\x02\x01\x04\x12\x04\xb3\x01\x02\
\n\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xb3\x01\x0b\x0f\n\r\n\x05\x04\
\x04\x02\x01\x01\x12\x04\xb3\x01\x10\x19\n\r\n\x05\x04\x04\x02\x01\x03\
\x12\x04\xb3\x01\x1c\x20\n\xa0\x01\n\x04\x04\x04\x02\x02\x12\x04\xb6\x01\
\x02%\x1a[\x20Used\x20internally\x20by\x20server\x20and\x20k8s\x20operat\
or\x20to\x20determine\x20who\x20manages\x20this\x20resource/mapping\n\"5\
\x20protolint:disable:this\x20FIELD_NAMES_LOWER_SNAKE_CASE\n\n\r\n\x05\
\x04\x04\x02\x02\x04\x12\x04\xb6\x01\x02\n\n\r\n\x05\x04\x04\x02\x02\x05\
\x12\x04\xb6\x01\x0b\x11\n\r\n\x05\x04\x04\x02\x02\x01\x12\x04\xb6\x01\
\x12\x1d\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\xb6\x01\x20$\nJ\n\x02\x04\
\x05\x12\x06\xbb\x01\0\xbf\x01\x01\x1a<\x20PipelineConfig\x20is\x20struc\
ture\x20used\x20in\x20protos.PipelineConfigs\n\n\x0b\n\x03\x04\x05\x01\
\x12\x04\xbb\x01\x08\x16\n\x0c\n\x04\x04\x05\x02\0\x12\x04\xbc\x01\x02\
\x10\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xbc\x01\x02\x08\n\r\n\x05\x04\
\x05\x02\0\x01\x12\x04\xbc\x01\t\x0b\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\
\xbc\x01\x0e\x0f\n\x0c\n\x04\x04\x05\x02\x01\x12\x04\xbd\x01\x02\x12\n\r\
\n\x05\x04\x05\x02\x01\x05\x12\x04\xbd\x01\x02\x06\n\r\n\x05\x04\x05\x02\
\x01\x01\x12\x04\xbd\x01\x07\r\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\xbd\
\x01\x10\x11\n\x0c\n\x04\x04\x05\x02\x02\x12\x04\xbe\x01\x02#\n\r\n\x05\
\x04\x05\x02\x02\x05\x12\x04\xbe\x01\x02\x07\n\r\n\x05\x04\x05\x02\x02\
\x01\x12\x04\xbe\x01\x08\x1e\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\xbe\
\x01!\"b\x06proto3\
";
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
file_descriptor_proto_lazy.get(|| {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
})
}
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
file_descriptor.get(|| {
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
let mut deps = ::std::vec::Vec::with_capacity(11);
deps.push(super::sp_notify::file_descriptor().clone());
deps.push(super::sp_steps_custom::file_descriptor().clone());
deps.push(super::sp_steps_decode::file_descriptor().clone());
deps.push(super::sp_steps_detective::file_descriptor().clone());
deps.push(super::sp_steps_encode::file_descriptor().clone());
deps.push(super::sp_steps_httprequest::file_descriptor().clone());
deps.push(super::sp_steps_inferschema::file_descriptor().clone());
deps.push(super::sp_steps_kv::file_descriptor().clone());
deps.push(super::sp_steps_schema_validation::file_descriptor().clone());
deps.push(super::sp_steps_transform::file_descriptor().clone());
deps.push(super::sp_steps_valid_json::file_descriptor().clone());
let mut messages = ::std::vec::Vec::with_capacity(6);
messages.push(Pipeline::generated_message_descriptor_data());
messages.push(PipelineStepConditions::generated_message_descriptor_data());
messages.push(PipelineStepNotification::generated_message_descriptor_data());
messages.push(PipelineStep::generated_message_descriptor_data());
messages.push(PipelineConfigs::generated_message_descriptor_data());
messages.push(PipelineConfig::generated_message_descriptor_data());
let mut enums = ::std::vec::Vec::with_capacity(3);
enums.push(PipelineDataFormat::generated_enum_descriptor_data());
enums.push(AbortCondition::generated_enum_descriptor_data());
enums.push(pipeline_step_notification::PayloadType::generated_enum_descriptor_data());
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
file_descriptor_proto(),
deps,
messages,
enums,
)
});
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
})
}