google_cloud_rust_raw/cloud/osconfig/agentendpoint/v1/

tasks.rs

// This file is generated by rust-protobuf 2.28.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![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_imports)]
#![allow(unused_results)]
//! Generated file from `google/cloud/osconfig/agentendpoint/v1/tasks.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_28_0;

#[derive(PartialEq,Clone,Default)]
pub struct Task {
    // message fields
    pub task_id: ::std::string::String,
    pub task_type: TaskType,
    pub task_directive: TaskDirective,
    pub service_labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // message oneof groups
    pub task_details: ::std::option::Option<Task_oneof_task_details>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Task {
    fn default() -> &'a Task {
        <Task as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
pub enum Task_oneof_task_details {
    apply_patches_task(ApplyPatchesTask),
    exec_step_task(ExecStepTask),
    apply_config_task(ApplyConfigTask),
}

impl Task {
    pub fn new() -> Task {
        ::std::default::Default::default()
    }

    // string task_id = 1;


    pub fn get_task_id(&self) -> &str {
        &self.task_id
    }
    pub fn clear_task_id(&mut self) {
        self.task_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_task_id(&mut self, v: ::std::string::String) {
        self.task_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_task_id(&mut self) -> &mut ::std::string::String {
        &mut self.task_id
    }

    // Take field
    pub fn take_task_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.task_id, ::std::string::String::new())
    }

    // .google.cloud.osconfig.agentendpoint.v1.TaskType task_type = 2;


    pub fn get_task_type(&self) -> TaskType {
        self.task_type
    }
    pub fn clear_task_type(&mut self) {
        self.task_type = TaskType::TASK_TYPE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_task_type(&mut self, v: TaskType) {
        self.task_type = v;
    }

    // .google.cloud.osconfig.agentendpoint.v1.TaskDirective task_directive = 3;


    pub fn get_task_directive(&self) -> TaskDirective {
        self.task_directive
    }
    pub fn clear_task_directive(&mut self) {
        self.task_directive = TaskDirective::TASK_DIRECTIVE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_task_directive(&mut self, v: TaskDirective) {
        self.task_directive = v;
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyPatchesTask apply_patches_task = 4;


    pub fn get_apply_patches_task(&self) -> &ApplyPatchesTask {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(ref v)) => v,
            _ => <ApplyPatchesTask as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_apply_patches_task(&mut self) {
        self.task_details = ::std::option::Option::None;
    }

    pub fn has_apply_patches_task(&self) -> bool {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_apply_patches_task(&mut self, v: ApplyPatchesTask) {
        self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(v))
    }

    // Mutable pointer to the field.
    pub fn mut_apply_patches_task(&mut self) -> &mut ApplyPatchesTask {
        if let ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(_)) = self.task_details {
        } else {
            self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(ApplyPatchesTask::new()));
        }
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_apply_patches_task(&mut self) -> ApplyPatchesTask {
        if self.has_apply_patches_task() {
            match self.task_details.take() {
                ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(v)) => v,
                _ => panic!(),
            }
        } else {
            ApplyPatchesTask::new()
        }
    }

    // .google.cloud.osconfig.agentendpoint.v1.ExecStepTask exec_step_task = 5;


    pub fn get_exec_step_task(&self) -> &ExecStepTask {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(ref v)) => v,
            _ => <ExecStepTask as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_exec_step_task(&mut self) {
        self.task_details = ::std::option::Option::None;
    }

    pub fn has_exec_step_task(&self) -> bool {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_exec_step_task(&mut self, v: ExecStepTask) {
        self.task_details = ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(v))
    }

    // Mutable pointer to the field.
    pub fn mut_exec_step_task(&mut self) -> &mut ExecStepTask {
        if let ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(_)) = self.task_details {
        } else {
            self.task_details = ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(ExecStepTask::new()));
        }
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_exec_step_task(&mut self) -> ExecStepTask {
        if self.has_exec_step_task() {
            match self.task_details.take() {
                ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(v)) => v,
                _ => panic!(),
            }
        } else {
            ExecStepTask::new()
        }
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyConfigTask apply_config_task = 7;


    pub fn get_apply_config_task(&self) -> &ApplyConfigTask {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(ref v)) => v,
            _ => <ApplyConfigTask as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_apply_config_task(&mut self) {
        self.task_details = ::std::option::Option::None;
    }

    pub fn has_apply_config_task(&self) -> bool {
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_apply_config_task(&mut self, v: ApplyConfigTask) {
        self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(v))
    }

    // Mutable pointer to the field.
    pub fn mut_apply_config_task(&mut self) -> &mut ApplyConfigTask {
        if let ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(_)) = self.task_details {
        } else {
            self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(ApplyConfigTask::new()));
        }
        match self.task_details {
            ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_apply_config_task(&mut self) -> ApplyConfigTask {
        if self.has_apply_config_task() {
            match self.task_details.take() {
                ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(v)) => v,
                _ => panic!(),
            }
        } else {
            ApplyConfigTask::new()
        }
    }

    // repeated .google.cloud.osconfig.agentendpoint.v1.Task.ServiceLabelsEntry service_labels = 6;


    pub fn get_service_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.service_labels
    }
    pub fn clear_service_labels(&mut self) {
        self.service_labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_service_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
        self.service_labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_service_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.service_labels
    }

    // Take field
    pub fn take_service_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.service_labels, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for Task {
    fn is_initialized(&self) -> bool {
        if let Some(Task_oneof_task_details::apply_patches_task(ref v)) = self.task_details {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Task_oneof_task_details::exec_step_task(ref v)) = self.task_details {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(Task_oneof_task_details::apply_config_task(ref v)) = self.task_details {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.task_id)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.task_type, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.task_directive, 3, &mut self.unknown_fields)?
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_patches_task(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.task_details = ::std::option::Option::Some(Task_oneof_task_details::exec_step_task(is.read_message()?));
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.task_details = ::std::option::Option::Some(Task_oneof_task_details::apply_config_task(is.read_message()?));
                },
                6 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.service_labels)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.task_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.task_id);
        }
        if self.task_type != TaskType::TASK_TYPE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.task_type);
        }
        if self.task_directive != TaskDirective::TASK_DIRECTIVE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(3, self.task_directive);
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(6, &self.service_labels);
        if let ::std::option::Option::Some(ref v) = self.task_details {
            match v {
                &Task_oneof_task_details::apply_patches_task(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Task_oneof_task_details::exec_step_task(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &Task_oneof_task_details::apply_config_task(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.task_id.is_empty() {
            os.write_string(1, &self.task_id)?;
        }
        if self.task_type != TaskType::TASK_TYPE_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.task_type))?;
        }
        if self.task_directive != TaskDirective::TASK_DIRECTIVE_UNSPECIFIED {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.task_directive))?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(6, &self.service_labels, os)?;
        if let ::std::option::Option::Some(ref v) = self.task_details {
            match v {
                &Task_oneof_task_details::apply_patches_task(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Task_oneof_task_details::exec_step_task(ref v) => {
                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &Task_oneof_task_details::apply_config_task(ref v) => {
                    os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Task {
        Task::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "task_id",
                |m: &Task| { &m.task_id },
                |m: &mut Task| { &mut m.task_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TaskType>>(
                "task_type",
                |m: &Task| { &m.task_type },
                |m: &mut Task| { &mut m.task_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TaskDirective>>(
                "task_directive",
                |m: &Task| { &m.task_directive },
                |m: &mut Task| { &mut m.task_directive },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ApplyPatchesTask>(
                "apply_patches_task",
                Task::has_apply_patches_task,
                Task::get_apply_patches_task,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ExecStepTask>(
                "exec_step_task",
                Task::has_exec_step_task,
                Task::get_exec_step_task,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ApplyConfigTask>(
                "apply_config_task",
                Task::has_apply_config_task,
                Task::get_apply_config_task,
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
                "service_labels",
                |m: &Task| { &m.service_labels },
                |m: &mut Task| { &mut m.service_labels },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Task>(
                "Task",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Task {
        static instance: ::protobuf::rt::LazyV2<Task> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Task::new)
    }
}

impl ::protobuf::Clear for Task {
    fn clear(&mut self) {
        self.task_id.clear();
        self.task_type = TaskType::TASK_TYPE_UNSPECIFIED;
        self.task_directive = TaskDirective::TASK_DIRECTIVE_UNSPECIFIED;
        self.task_details = ::std::option::Option::None;
        self.task_details = ::std::option::Option::None;
        self.task_details = ::std::option::Option::None;
        self.service_labels.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Task {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Task {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyPatchesTask {
    // message fields
    pub patch_config: ::protobuf::SingularPtrField<super::patch_jobs::PatchConfig>,
    pub dry_run: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyPatchesTask {
    fn default() -> &'a ApplyPatchesTask {
        <ApplyPatchesTask as ::protobuf::Message>::default_instance()
    }
}

impl ApplyPatchesTask {
    pub fn new() -> ApplyPatchesTask {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.PatchConfig patch_config = 1;


    pub fn get_patch_config(&self) -> &super::patch_jobs::PatchConfig {
        self.patch_config.as_ref().unwrap_or_else(|| <super::patch_jobs::PatchConfig as ::protobuf::Message>::default_instance())
    }
    pub fn clear_patch_config(&mut self) {
        self.patch_config.clear();
    }

    pub fn has_patch_config(&self) -> bool {
        self.patch_config.is_some()
    }

    // Param is passed by value, moved
    pub fn set_patch_config(&mut self, v: super::patch_jobs::PatchConfig) {
        self.patch_config = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_patch_config(&mut self) -> &mut super::patch_jobs::PatchConfig {
        if self.patch_config.is_none() {
            self.patch_config.set_default();
        }
        self.patch_config.as_mut().unwrap()
    }

    // Take field
    pub fn take_patch_config(&mut self) -> super::patch_jobs::PatchConfig {
        self.patch_config.take().unwrap_or_else(|| super::patch_jobs::PatchConfig::new())
    }

    // bool dry_run = 3;


    pub fn get_dry_run(&self) -> bool {
        self.dry_run
    }
    pub fn clear_dry_run(&mut self) {
        self.dry_run = false;
    }

    // Param is passed by value, moved
    pub fn set_dry_run(&mut self, v: bool) {
        self.dry_run = v;
    }
}

impl ::protobuf::Message for ApplyPatchesTask {
    fn is_initialized(&self) -> bool {
        for v in &self.patch_config {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.patch_config)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.dry_run = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.patch_config.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.dry_run != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.patch_config.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.dry_run != false {
            os.write_bool(3, self.dry_run)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyPatchesTask {
        ApplyPatchesTask::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::patch_jobs::PatchConfig>>(
                "patch_config",
                |m: &ApplyPatchesTask| { &m.patch_config },
                |m: &mut ApplyPatchesTask| { &mut m.patch_config },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "dry_run",
                |m: &ApplyPatchesTask| { &m.dry_run },
                |m: &mut ApplyPatchesTask| { &mut m.dry_run },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyPatchesTask>(
                "ApplyPatchesTask",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyPatchesTask {
        static instance: ::protobuf::rt::LazyV2<ApplyPatchesTask> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyPatchesTask::new)
    }
}

impl ::protobuf::Clear for ApplyPatchesTask {
    fn clear(&mut self) {
        self.patch_config.clear();
        self.dry_run = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyPatchesTask {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyPatchesTask {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyPatchesTaskProgress {
    // message fields
    pub state: ApplyPatchesTaskProgress_State,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyPatchesTaskProgress {
    fn default() -> &'a ApplyPatchesTaskProgress {
        <ApplyPatchesTaskProgress as ::protobuf::Message>::default_instance()
    }
}

impl ApplyPatchesTaskProgress {
    pub fn new() -> ApplyPatchesTaskProgress {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyPatchesTaskProgress.State state = 1;


    pub fn get_state(&self) -> ApplyPatchesTaskProgress_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ApplyPatchesTaskProgress_State) {
        self.state = v;
    }
}

impl ::protobuf::Message for ApplyPatchesTaskProgress {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyPatchesTaskProgress {
        ApplyPatchesTaskProgress::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ApplyPatchesTaskProgress_State>>(
                "state",
                |m: &ApplyPatchesTaskProgress| { &m.state },
                |m: &mut ApplyPatchesTaskProgress| { &mut m.state },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyPatchesTaskProgress>(
                "ApplyPatchesTaskProgress",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyPatchesTaskProgress {
        static instance: ::protobuf::rt::LazyV2<ApplyPatchesTaskProgress> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyPatchesTaskProgress::new)
    }
}

impl ::protobuf::Clear for ApplyPatchesTaskProgress {
    fn clear(&mut self) {
        self.state = ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyPatchesTaskProgress {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyPatchesTaskProgress {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ApplyPatchesTaskProgress_State {
    STATE_UNSPECIFIED = 0,
    STARTED = 4,
    DOWNLOADING_PATCHES = 1,
    APPLYING_PATCHES = 2,
    REBOOTING = 3,
}

impl ::protobuf::ProtobufEnum for ApplyPatchesTaskProgress_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ApplyPatchesTaskProgress_State> {
        match value {
            0 => ::std::option::Option::Some(ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED),
            4 => ::std::option::Option::Some(ApplyPatchesTaskProgress_State::STARTED),
            1 => ::std::option::Option::Some(ApplyPatchesTaskProgress_State::DOWNLOADING_PATCHES),
            2 => ::std::option::Option::Some(ApplyPatchesTaskProgress_State::APPLYING_PATCHES),
            3 => ::std::option::Option::Some(ApplyPatchesTaskProgress_State::REBOOTING),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ApplyPatchesTaskProgress_State] = &[
            ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED,
            ApplyPatchesTaskProgress_State::STARTED,
            ApplyPatchesTaskProgress_State::DOWNLOADING_PATCHES,
            ApplyPatchesTaskProgress_State::APPLYING_PATCHES,
            ApplyPatchesTaskProgress_State::REBOOTING,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ApplyPatchesTaskProgress_State>("ApplyPatchesTaskProgress.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ApplyPatchesTaskProgress_State {
}

impl ::std::default::Default for ApplyPatchesTaskProgress_State {
    fn default() -> Self {
        ApplyPatchesTaskProgress_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyPatchesTaskProgress_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyPatchesTaskOutput {
    // message fields
    pub state: ApplyPatchesTaskOutput_State,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyPatchesTaskOutput {
    fn default() -> &'a ApplyPatchesTaskOutput {
        <ApplyPatchesTaskOutput as ::protobuf::Message>::default_instance()
    }
}

impl ApplyPatchesTaskOutput {
    pub fn new() -> ApplyPatchesTaskOutput {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyPatchesTaskOutput.State state = 1;


    pub fn get_state(&self) -> ApplyPatchesTaskOutput_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ApplyPatchesTaskOutput_State) {
        self.state = v;
    }
}

impl ::protobuf::Message for ApplyPatchesTaskOutput {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyPatchesTaskOutput {
        ApplyPatchesTaskOutput::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ApplyPatchesTaskOutput_State>>(
                "state",
                |m: &ApplyPatchesTaskOutput| { &m.state },
                |m: &mut ApplyPatchesTaskOutput| { &mut m.state },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyPatchesTaskOutput>(
                "ApplyPatchesTaskOutput",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyPatchesTaskOutput {
        static instance: ::protobuf::rt::LazyV2<ApplyPatchesTaskOutput> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyPatchesTaskOutput::new)
    }
}

impl ::protobuf::Clear for ApplyPatchesTaskOutput {
    fn clear(&mut self) {
        self.state = ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyPatchesTaskOutput {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyPatchesTaskOutput {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ApplyPatchesTaskOutput_State {
    STATE_UNSPECIFIED = 0,
    SUCCEEDED = 1,
    SUCCEEDED_REBOOT_REQUIRED = 2,
    FAILED = 3,
}

impl ::protobuf::ProtobufEnum for ApplyPatchesTaskOutput_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ApplyPatchesTaskOutput_State> {
        match value {
            0 => ::std::option::Option::Some(ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(ApplyPatchesTaskOutput_State::SUCCEEDED),
            2 => ::std::option::Option::Some(ApplyPatchesTaskOutput_State::SUCCEEDED_REBOOT_REQUIRED),
            3 => ::std::option::Option::Some(ApplyPatchesTaskOutput_State::FAILED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ApplyPatchesTaskOutput_State] = &[
            ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED,
            ApplyPatchesTaskOutput_State::SUCCEEDED,
            ApplyPatchesTaskOutput_State::SUCCEEDED_REBOOT_REQUIRED,
            ApplyPatchesTaskOutput_State::FAILED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ApplyPatchesTaskOutput_State>("ApplyPatchesTaskOutput.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ApplyPatchesTaskOutput_State {
}

impl ::std::default::Default for ApplyPatchesTaskOutput_State {
    fn default() -> Self {
        ApplyPatchesTaskOutput_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyPatchesTaskOutput_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecStepTask {
    // message fields
    pub exec_step: ::protobuf::SingularPtrField<super::patch_jobs::ExecStep>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecStepTask {
    fn default() -> &'a ExecStepTask {
        <ExecStepTask as ::protobuf::Message>::default_instance()
    }
}

impl ExecStepTask {
    pub fn new() -> ExecStepTask {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ExecStep exec_step = 1;


    pub fn get_exec_step(&self) -> &super::patch_jobs::ExecStep {
        self.exec_step.as_ref().unwrap_or_else(|| <super::patch_jobs::ExecStep as ::protobuf::Message>::default_instance())
    }
    pub fn clear_exec_step(&mut self) {
        self.exec_step.clear();
    }

    pub fn has_exec_step(&self) -> bool {
        self.exec_step.is_some()
    }

    // Param is passed by value, moved
    pub fn set_exec_step(&mut self, v: super::patch_jobs::ExecStep) {
        self.exec_step = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_exec_step(&mut self) -> &mut super::patch_jobs::ExecStep {
        if self.exec_step.is_none() {
            self.exec_step.set_default();
        }
        self.exec_step.as_mut().unwrap()
    }

    // Take field
    pub fn take_exec_step(&mut self) -> super::patch_jobs::ExecStep {
        self.exec_step.take().unwrap_or_else(|| super::patch_jobs::ExecStep::new())
    }
}

impl ::protobuf::Message for ExecStepTask {
    fn is_initialized(&self) -> bool {
        for v in &self.exec_step {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.exec_step)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.exec_step.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.exec_step.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecStepTask {
        ExecStepTask::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::patch_jobs::ExecStep>>(
                "exec_step",
                |m: &ExecStepTask| { &m.exec_step },
                |m: &mut ExecStepTask| { &mut m.exec_step },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecStepTask>(
                "ExecStepTask",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecStepTask {
        static instance: ::protobuf::rt::LazyV2<ExecStepTask> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecStepTask::new)
    }
}

impl ::protobuf::Clear for ExecStepTask {
    fn clear(&mut self) {
        self.exec_step.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecStepTask {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecStepTask {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecStepTaskProgress {
    // message fields
    pub state: ExecStepTaskProgress_State,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecStepTaskProgress {
    fn default() -> &'a ExecStepTaskProgress {
        <ExecStepTaskProgress as ::protobuf::Message>::default_instance()
    }
}

impl ExecStepTaskProgress {
    pub fn new() -> ExecStepTaskProgress {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ExecStepTaskProgress.State state = 1;


    pub fn get_state(&self) -> ExecStepTaskProgress_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ExecStepTaskProgress_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ExecStepTaskProgress_State) {
        self.state = v;
    }
}

impl ::protobuf::Message for ExecStepTaskProgress {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ExecStepTaskProgress_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ExecStepTaskProgress_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecStepTaskProgress {
        ExecStepTaskProgress::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ExecStepTaskProgress_State>>(
                "state",
                |m: &ExecStepTaskProgress| { &m.state },
                |m: &mut ExecStepTaskProgress| { &mut m.state },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecStepTaskProgress>(
                "ExecStepTaskProgress",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecStepTaskProgress {
        static instance: ::protobuf::rt::LazyV2<ExecStepTaskProgress> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecStepTaskProgress::new)
    }
}

impl ::protobuf::Clear for ExecStepTaskProgress {
    fn clear(&mut self) {
        self.state = ExecStepTaskProgress_State::STATE_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecStepTaskProgress {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecStepTaskProgress {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ExecStepTaskProgress_State {
    STATE_UNSPECIFIED = 0,
    STARTED = 1,
}

impl ::protobuf::ProtobufEnum for ExecStepTaskProgress_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ExecStepTaskProgress_State> {
        match value {
            0 => ::std::option::Option::Some(ExecStepTaskProgress_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(ExecStepTaskProgress_State::STARTED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ExecStepTaskProgress_State] = &[
            ExecStepTaskProgress_State::STATE_UNSPECIFIED,
            ExecStepTaskProgress_State::STARTED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ExecStepTaskProgress_State>("ExecStepTaskProgress.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ExecStepTaskProgress_State {
}

impl ::std::default::Default for ExecStepTaskProgress_State {
    fn default() -> Self {
        ExecStepTaskProgress_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecStepTaskProgress_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecStepTaskOutput {
    // message fields
    pub state: ExecStepTaskOutput_State,
    pub exit_code: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecStepTaskOutput {
    fn default() -> &'a ExecStepTaskOutput {
        <ExecStepTaskOutput as ::protobuf::Message>::default_instance()
    }
}

impl ExecStepTaskOutput {
    pub fn new() -> ExecStepTaskOutput {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ExecStepTaskOutput.State state = 1;


    pub fn get_state(&self) -> ExecStepTaskOutput_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ExecStepTaskOutput_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ExecStepTaskOutput_State) {
        self.state = v;
    }

    // int32 exit_code = 2;


    pub fn get_exit_code(&self) -> i32 {
        self.exit_code
    }
    pub fn clear_exit_code(&mut self) {
        self.exit_code = 0;
    }

    // Param is passed by value, moved
    pub fn set_exit_code(&mut self, v: i32) {
        self.exit_code = v;
    }
}

impl ::protobuf::Message for ExecStepTaskOutput {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.exit_code = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ExecStepTaskOutput_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if self.exit_code != 0 {
            my_size += ::protobuf::rt::value_size(2, self.exit_code, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ExecStepTaskOutput_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if self.exit_code != 0 {
            os.write_int32(2, self.exit_code)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecStepTaskOutput {
        ExecStepTaskOutput::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ExecStepTaskOutput_State>>(
                "state",
                |m: &ExecStepTaskOutput| { &m.state },
                |m: &mut ExecStepTaskOutput| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "exit_code",
                |m: &ExecStepTaskOutput| { &m.exit_code },
                |m: &mut ExecStepTaskOutput| { &mut m.exit_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecStepTaskOutput>(
                "ExecStepTaskOutput",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecStepTaskOutput {
        static instance: ::protobuf::rt::LazyV2<ExecStepTaskOutput> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecStepTaskOutput::new)
    }
}

impl ::protobuf::Clear for ExecStepTaskOutput {
    fn clear(&mut self) {
        self.state = ExecStepTaskOutput_State::STATE_UNSPECIFIED;
        self.exit_code = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecStepTaskOutput {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecStepTaskOutput {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ExecStepTaskOutput_State {
    STATE_UNSPECIFIED = 0,
    COMPLETED = 1,
    TIMED_OUT = 2,
    CANCELLED = 3,
}

impl ::protobuf::ProtobufEnum for ExecStepTaskOutput_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ExecStepTaskOutput_State> {
        match value {
            0 => ::std::option::Option::Some(ExecStepTaskOutput_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(ExecStepTaskOutput_State::COMPLETED),
            2 => ::std::option::Option::Some(ExecStepTaskOutput_State::TIMED_OUT),
            3 => ::std::option::Option::Some(ExecStepTaskOutput_State::CANCELLED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ExecStepTaskOutput_State] = &[
            ExecStepTaskOutput_State::STATE_UNSPECIFIED,
            ExecStepTaskOutput_State::COMPLETED,
            ExecStepTaskOutput_State::TIMED_OUT,
            ExecStepTaskOutput_State::CANCELLED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ExecStepTaskOutput_State>("ExecStepTaskOutput.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ExecStepTaskOutput_State {
}

impl ::std::default::Default for ExecStepTaskOutput_State {
    fn default() -> Self {
        ExecStepTaskOutput_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecStepTaskOutput_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyConfigTask {
    // message fields
    pub os_policies: ::protobuf::RepeatedField<ApplyConfigTask_OSPolicy>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyConfigTask {
    fn default() -> &'a ApplyConfigTask {
        <ApplyConfigTask as ::protobuf::Message>::default_instance()
    }
}

impl ApplyConfigTask {
    pub fn new() -> ApplyConfigTask {
        ::std::default::Default::default()
    }

    // repeated .google.cloud.osconfig.agentendpoint.v1.ApplyConfigTask.OSPolicy os_policies = 1;


    pub fn get_os_policies(&self) -> &[ApplyConfigTask_OSPolicy] {
        &self.os_policies
    }
    pub fn clear_os_policies(&mut self) {
        self.os_policies.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policies(&mut self, v: ::protobuf::RepeatedField<ApplyConfigTask_OSPolicy>) {
        self.os_policies = v;
    }

    // Mutable pointer to the field.
    pub fn mut_os_policies(&mut self) -> &mut ::protobuf::RepeatedField<ApplyConfigTask_OSPolicy> {
        &mut self.os_policies
    }

    // Take field
    pub fn take_os_policies(&mut self) -> ::protobuf::RepeatedField<ApplyConfigTask_OSPolicy> {
        ::std::mem::replace(&mut self.os_policies, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ApplyConfigTask {
    fn is_initialized(&self) -> bool {
        for v in &self.os_policies {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.os_policies)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.os_policies {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.os_policies {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyConfigTask {
        ApplyConfigTask::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ApplyConfigTask_OSPolicy>>(
                "os_policies",
                |m: &ApplyConfigTask| { &m.os_policies },
                |m: &mut ApplyConfigTask| { &mut m.os_policies },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyConfigTask>(
                "ApplyConfigTask",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyConfigTask {
        static instance: ::protobuf::rt::LazyV2<ApplyConfigTask> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyConfigTask::new)
    }
}

impl ::protobuf::Clear for ApplyConfigTask {
    fn clear(&mut self) {
        self.os_policies.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyConfigTask {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTask {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyConfigTask_OSPolicy {
    // message fields
    pub id: ::std::string::String,
    pub mode: super::os_policy::OSPolicy_Mode,
    pub os_policy_assignment: ::std::string::String,
    pub resources: ::protobuf::RepeatedField<super::os_policy::OSPolicy_Resource>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyConfigTask_OSPolicy {
    fn default() -> &'a ApplyConfigTask_OSPolicy {
        <ApplyConfigTask_OSPolicy as ::protobuf::Message>::default_instance()
    }
}

impl ApplyConfigTask_OSPolicy {
    pub fn new() -> ApplyConfigTask_OSPolicy {
        ::std::default::Default::default()
    }

    // string id = 1;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: ::std::string::String) {
        self.id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_id(&mut self) -> &mut ::std::string::String {
        &mut self.id
    }

    // Take field
    pub fn take_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.id, ::std::string::String::new())
    }

    // .google.cloud.osconfig.agentendpoint.v1.OSPolicy.Mode mode = 2;


    pub fn get_mode(&self) -> super::os_policy::OSPolicy_Mode {
        self.mode
    }
    pub fn clear_mode(&mut self) {
        self.mode = super::os_policy::OSPolicy_Mode::MODE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_mode(&mut self, v: super::os_policy::OSPolicy_Mode) {
        self.mode = v;
    }

    // string os_policy_assignment = 3;


    pub fn get_os_policy_assignment(&self) -> &str {
        &self.os_policy_assignment
    }
    pub fn clear_os_policy_assignment(&mut self) {
        self.os_policy_assignment.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policy_assignment(&mut self, v: ::std::string::String) {
        self.os_policy_assignment = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_os_policy_assignment(&mut self) -> &mut ::std::string::String {
        &mut self.os_policy_assignment
    }

    // Take field
    pub fn take_os_policy_assignment(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.os_policy_assignment, ::std::string::String::new())
    }

    // repeated .google.cloud.osconfig.agentendpoint.v1.OSPolicy.Resource resources = 4;


    pub fn get_resources(&self) -> &[super::os_policy::OSPolicy_Resource] {
        &self.resources
    }
    pub fn clear_resources(&mut self) {
        self.resources.clear();
    }

    // Param is passed by value, moved
    pub fn set_resources(&mut self, v: ::protobuf::RepeatedField<super::os_policy::OSPolicy_Resource>) {
        self.resources = v;
    }

    // Mutable pointer to the field.
    pub fn mut_resources(&mut self) -> &mut ::protobuf::RepeatedField<super::os_policy::OSPolicy_Resource> {
        &mut self.resources
    }

    // Take field
    pub fn take_resources(&mut self) -> ::protobuf::RepeatedField<super::os_policy::OSPolicy_Resource> {
        ::std::mem::replace(&mut self.resources, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ApplyConfigTask_OSPolicy {
    fn is_initialized(&self) -> bool {
        for v in &self.resources {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.mode, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.os_policy_assignment)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.resources)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.id);
        }
        if self.mode != super::os_policy::OSPolicy_Mode::MODE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.mode);
        }
        if !self.os_policy_assignment.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.os_policy_assignment);
        }
        for value in &self.resources {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.id.is_empty() {
            os.write_string(1, &self.id)?;
        }
        if self.mode != super::os_policy::OSPolicy_Mode::MODE_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.mode))?;
        }
        if !self.os_policy_assignment.is_empty() {
            os.write_string(3, &self.os_policy_assignment)?;
        }
        for v in &self.resources {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyConfigTask_OSPolicy {
        ApplyConfigTask_OSPolicy::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "id",
                |m: &ApplyConfigTask_OSPolicy| { &m.id },
                |m: &mut ApplyConfigTask_OSPolicy| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::os_policy::OSPolicy_Mode>>(
                "mode",
                |m: &ApplyConfigTask_OSPolicy| { &m.mode },
                |m: &mut ApplyConfigTask_OSPolicy| { &mut m.mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "os_policy_assignment",
                |m: &ApplyConfigTask_OSPolicy| { &m.os_policy_assignment },
                |m: &mut ApplyConfigTask_OSPolicy| { &mut m.os_policy_assignment },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::os_policy::OSPolicy_Resource>>(
                "resources",
                |m: &ApplyConfigTask_OSPolicy| { &m.resources },
                |m: &mut ApplyConfigTask_OSPolicy| { &mut m.resources },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyConfigTask_OSPolicy>(
                "ApplyConfigTask.OSPolicy",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyConfigTask_OSPolicy {
        static instance: ::protobuf::rt::LazyV2<ApplyConfigTask_OSPolicy> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyConfigTask_OSPolicy::new)
    }
}

impl ::protobuf::Clear for ApplyConfigTask_OSPolicy {
    fn clear(&mut self) {
        self.id.clear();
        self.mode = super::os_policy::OSPolicy_Mode::MODE_UNSPECIFIED;
        self.os_policy_assignment.clear();
        self.resources.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyConfigTask_OSPolicy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTask_OSPolicy {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyConfigTaskProgress {
    // message fields
    pub state: ApplyConfigTaskProgress_State,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyConfigTaskProgress {
    fn default() -> &'a ApplyConfigTaskProgress {
        <ApplyConfigTaskProgress as ::protobuf::Message>::default_instance()
    }
}

impl ApplyConfigTaskProgress {
    pub fn new() -> ApplyConfigTaskProgress {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyConfigTaskProgress.State state = 1;


    pub fn get_state(&self) -> ApplyConfigTaskProgress_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ApplyConfigTaskProgress_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ApplyConfigTaskProgress_State) {
        self.state = v;
    }
}

impl ::protobuf::Message for ApplyConfigTaskProgress {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ApplyConfigTaskProgress_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ApplyConfigTaskProgress_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyConfigTaskProgress {
        ApplyConfigTaskProgress::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ApplyConfigTaskProgress_State>>(
                "state",
                |m: &ApplyConfigTaskProgress| { &m.state },
                |m: &mut ApplyConfigTaskProgress| { &mut m.state },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyConfigTaskProgress>(
                "ApplyConfigTaskProgress",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyConfigTaskProgress {
        static instance: ::protobuf::rt::LazyV2<ApplyConfigTaskProgress> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyConfigTaskProgress::new)
    }
}

impl ::protobuf::Clear for ApplyConfigTaskProgress {
    fn clear(&mut self) {
        self.state = ApplyConfigTaskProgress_State::STATE_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyConfigTaskProgress {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTaskProgress {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ApplyConfigTaskProgress_State {
    STATE_UNSPECIFIED = 0,
    STARTED = 1,
    APPLYING_CONFIG = 2,
}

impl ::protobuf::ProtobufEnum for ApplyConfigTaskProgress_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ApplyConfigTaskProgress_State> {
        match value {
            0 => ::std::option::Option::Some(ApplyConfigTaskProgress_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(ApplyConfigTaskProgress_State::STARTED),
            2 => ::std::option::Option::Some(ApplyConfigTaskProgress_State::APPLYING_CONFIG),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ApplyConfigTaskProgress_State] = &[
            ApplyConfigTaskProgress_State::STATE_UNSPECIFIED,
            ApplyConfigTaskProgress_State::STARTED,
            ApplyConfigTaskProgress_State::APPLYING_CONFIG,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ApplyConfigTaskProgress_State>("ApplyConfigTaskProgress.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ApplyConfigTaskProgress_State {
}

impl ::std::default::Default for ApplyConfigTaskProgress_State {
    fn default() -> Self {
        ApplyConfigTaskProgress_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTaskProgress_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyConfigTaskOutput {
    // message fields
    pub state: ApplyConfigTaskOutput_State,
    pub os_policy_results: ::protobuf::RepeatedField<ApplyConfigTaskOutput_OSPolicyResult>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyConfigTaskOutput {
    fn default() -> &'a ApplyConfigTaskOutput {
        <ApplyConfigTaskOutput as ::protobuf::Message>::default_instance()
    }
}

impl ApplyConfigTaskOutput {
    pub fn new() -> ApplyConfigTaskOutput {
        ::std::default::Default::default()
    }

    // .google.cloud.osconfig.agentendpoint.v1.ApplyConfigTaskOutput.State state = 1;


    pub fn get_state(&self) -> ApplyConfigTaskOutput_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = ApplyConfigTaskOutput_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: ApplyConfigTaskOutput_State) {
        self.state = v;
    }

    // repeated .google.cloud.osconfig.agentendpoint.v1.ApplyConfigTaskOutput.OSPolicyResult os_policy_results = 2;


    pub fn get_os_policy_results(&self) -> &[ApplyConfigTaskOutput_OSPolicyResult] {
        &self.os_policy_results
    }
    pub fn clear_os_policy_results(&mut self) {
        self.os_policy_results.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policy_results(&mut self, v: ::protobuf::RepeatedField<ApplyConfigTaskOutput_OSPolicyResult>) {
        self.os_policy_results = v;
    }

    // Mutable pointer to the field.
    pub fn mut_os_policy_results(&mut self) -> &mut ::protobuf::RepeatedField<ApplyConfigTaskOutput_OSPolicyResult> {
        &mut self.os_policy_results
    }

    // Take field
    pub fn take_os_policy_results(&mut self) -> ::protobuf::RepeatedField<ApplyConfigTaskOutput_OSPolicyResult> {
        ::std::mem::replace(&mut self.os_policy_results, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ApplyConfigTaskOutput {
    fn is_initialized(&self) -> bool {
        for v in &self.os_policy_results {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.os_policy_results)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.state != ApplyConfigTaskOutput_State::STATE_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        for value in &self.os_policy_results {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.state != ApplyConfigTaskOutput_State::STATE_UNSPECIFIED {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        for v in &self.os_policy_results {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyConfigTaskOutput {
        ApplyConfigTaskOutput::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ApplyConfigTaskOutput_State>>(
                "state",
                |m: &ApplyConfigTaskOutput| { &m.state },
                |m: &mut ApplyConfigTaskOutput| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ApplyConfigTaskOutput_OSPolicyResult>>(
                "os_policy_results",
                |m: &ApplyConfigTaskOutput| { &m.os_policy_results },
                |m: &mut ApplyConfigTaskOutput| { &mut m.os_policy_results },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyConfigTaskOutput>(
                "ApplyConfigTaskOutput",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyConfigTaskOutput {
        static instance: ::protobuf::rt::LazyV2<ApplyConfigTaskOutput> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyConfigTaskOutput::new)
    }
}

impl ::protobuf::Clear for ApplyConfigTaskOutput {
    fn clear(&mut self) {
        self.state = ApplyConfigTaskOutput_State::STATE_UNSPECIFIED;
        self.os_policy_results.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyConfigTaskOutput {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTaskOutput {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ApplyConfigTaskOutput_OSPolicyResult {
    // message fields
    pub os_policy_id: ::std::string::String,
    pub os_policy_assignment: ::std::string::String,
    pub os_policy_resource_compliances: ::protobuf::RepeatedField<super::config_common::OSPolicyResourceCompliance>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ApplyConfigTaskOutput_OSPolicyResult {
    fn default() -> &'a ApplyConfigTaskOutput_OSPolicyResult {
        <ApplyConfigTaskOutput_OSPolicyResult as ::protobuf::Message>::default_instance()
    }
}

impl ApplyConfigTaskOutput_OSPolicyResult {
    pub fn new() -> ApplyConfigTaskOutput_OSPolicyResult {
        ::std::default::Default::default()
    }

    // string os_policy_id = 1;


    pub fn get_os_policy_id(&self) -> &str {
        &self.os_policy_id
    }
    pub fn clear_os_policy_id(&mut self) {
        self.os_policy_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policy_id(&mut self, v: ::std::string::String) {
        self.os_policy_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_os_policy_id(&mut self) -> &mut ::std::string::String {
        &mut self.os_policy_id
    }

    // Take field
    pub fn take_os_policy_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.os_policy_id, ::std::string::String::new())
    }

    // string os_policy_assignment = 2;


    pub fn get_os_policy_assignment(&self) -> &str {
        &self.os_policy_assignment
    }
    pub fn clear_os_policy_assignment(&mut self) {
        self.os_policy_assignment.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policy_assignment(&mut self, v: ::std::string::String) {
        self.os_policy_assignment = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_os_policy_assignment(&mut self) -> &mut ::std::string::String {
        &mut self.os_policy_assignment
    }

    // Take field
    pub fn take_os_policy_assignment(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.os_policy_assignment, ::std::string::String::new())
    }

    // repeated .google.cloud.osconfig.agentendpoint.v1.OSPolicyResourceCompliance os_policy_resource_compliances = 3;


    pub fn get_os_policy_resource_compliances(&self) -> &[super::config_common::OSPolicyResourceCompliance] {
        &self.os_policy_resource_compliances
    }
    pub fn clear_os_policy_resource_compliances(&mut self) {
        self.os_policy_resource_compliances.clear();
    }

    // Param is passed by value, moved
    pub fn set_os_policy_resource_compliances(&mut self, v: ::protobuf::RepeatedField<super::config_common::OSPolicyResourceCompliance>) {
        self.os_policy_resource_compliances = v;
    }

    // Mutable pointer to the field.
    pub fn mut_os_policy_resource_compliances(&mut self) -> &mut ::protobuf::RepeatedField<super::config_common::OSPolicyResourceCompliance> {
        &mut self.os_policy_resource_compliances
    }

    // Take field
    pub fn take_os_policy_resource_compliances(&mut self) -> ::protobuf::RepeatedField<super::config_common::OSPolicyResourceCompliance> {
        ::std::mem::replace(&mut self.os_policy_resource_compliances, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ApplyConfigTaskOutput_OSPolicyResult {
    fn is_initialized(&self) -> bool {
        for v in &self.os_policy_resource_compliances {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.os_policy_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.os_policy_assignment)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.os_policy_resource_compliances)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.os_policy_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.os_policy_id);
        }
        if !self.os_policy_assignment.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.os_policy_assignment);
        }
        for value in &self.os_policy_resource_compliances {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.os_policy_id.is_empty() {
            os.write_string(1, &self.os_policy_id)?;
        }
        if !self.os_policy_assignment.is_empty() {
            os.write_string(2, &self.os_policy_assignment)?;
        }
        for v in &self.os_policy_resource_compliances {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ApplyConfigTaskOutput_OSPolicyResult {
        ApplyConfigTaskOutput_OSPolicyResult::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "os_policy_id",
                |m: &ApplyConfigTaskOutput_OSPolicyResult| { &m.os_policy_id },
                |m: &mut ApplyConfigTaskOutput_OSPolicyResult| { &mut m.os_policy_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "os_policy_assignment",
                |m: &ApplyConfigTaskOutput_OSPolicyResult| { &m.os_policy_assignment },
                |m: &mut ApplyConfigTaskOutput_OSPolicyResult| { &mut m.os_policy_assignment },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::config_common::OSPolicyResourceCompliance>>(
                "os_policy_resource_compliances",
                |m: &ApplyConfigTaskOutput_OSPolicyResult| { &m.os_policy_resource_compliances },
                |m: &mut ApplyConfigTaskOutput_OSPolicyResult| { &mut m.os_policy_resource_compliances },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ApplyConfigTaskOutput_OSPolicyResult>(
                "ApplyConfigTaskOutput.OSPolicyResult",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ApplyConfigTaskOutput_OSPolicyResult {
        static instance: ::protobuf::rt::LazyV2<ApplyConfigTaskOutput_OSPolicyResult> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ApplyConfigTaskOutput_OSPolicyResult::new)
    }
}

impl ::protobuf::Clear for ApplyConfigTaskOutput_OSPolicyResult {
    fn clear(&mut self) {
        self.os_policy_id.clear();
        self.os_policy_assignment.clear();
        self.os_policy_resource_compliances.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ApplyConfigTaskOutput_OSPolicyResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTaskOutput_OSPolicyResult {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ApplyConfigTaskOutput_State {
    STATE_UNSPECIFIED = 0,
    SUCCEEDED = 1,
    FAILED = 2,
    CANCELLED = 3,
}

impl ::protobuf::ProtobufEnum for ApplyConfigTaskOutput_State {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ApplyConfigTaskOutput_State> {
        match value {
            0 => ::std::option::Option::Some(ApplyConfigTaskOutput_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(ApplyConfigTaskOutput_State::SUCCEEDED),
            2 => ::std::option::Option::Some(ApplyConfigTaskOutput_State::FAILED),
            3 => ::std::option::Option::Some(ApplyConfigTaskOutput_State::CANCELLED),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ApplyConfigTaskOutput_State] = &[
            ApplyConfigTaskOutput_State::STATE_UNSPECIFIED,
            ApplyConfigTaskOutput_State::SUCCEEDED,
            ApplyConfigTaskOutput_State::FAILED,
            ApplyConfigTaskOutput_State::CANCELLED,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ApplyConfigTaskOutput_State>("ApplyConfigTaskOutput.State", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ApplyConfigTaskOutput_State {
}

impl ::std::default::Default for ApplyConfigTaskOutput_State {
    fn default() -> Self {
        ApplyConfigTaskOutput_State::STATE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for ApplyConfigTaskOutput_State {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TaskDirective {
    TASK_DIRECTIVE_UNSPECIFIED = 0,
    CONTINUE = 1,
    STOP = 2,
}

impl ::protobuf::ProtobufEnum for TaskDirective {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<TaskDirective> {
        match value {
            0 => ::std::option::Option::Some(TaskDirective::TASK_DIRECTIVE_UNSPECIFIED),
            1 => ::std::option::Option::Some(TaskDirective::CONTINUE),
            2 => ::std::option::Option::Some(TaskDirective::STOP),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [TaskDirective] = &[
            TaskDirective::TASK_DIRECTIVE_UNSPECIFIED,
            TaskDirective::CONTINUE,
            TaskDirective::STOP,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<TaskDirective>("TaskDirective", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for TaskDirective {
}

impl ::std::default::Default for TaskDirective {
    fn default() -> Self {
        TaskDirective::TASK_DIRECTIVE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskDirective {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum TaskType {
    TASK_TYPE_UNSPECIFIED = 0,
    APPLY_PATCHES = 1,
    EXEC_STEP_TASK = 2,
    APPLY_CONFIG_TASK = 3,
}

impl ::protobuf::ProtobufEnum for TaskType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<TaskType> {
        match value {
            0 => ::std::option::Option::Some(TaskType::TASK_TYPE_UNSPECIFIED),
            1 => ::std::option::Option::Some(TaskType::APPLY_PATCHES),
            2 => ::std::option::Option::Some(TaskType::EXEC_STEP_TASK),
            3 => ::std::option::Option::Some(TaskType::APPLY_CONFIG_TASK),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [TaskType] = &[
            TaskType::TASK_TYPE_UNSPECIFIED,
            TaskType::APPLY_PATCHES,
            TaskType::EXEC_STEP_TASK,
            TaskType::APPLY_CONFIG_TASK,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<TaskType>("TaskType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for TaskType {
}

impl ::std::default::Default for TaskType {
    fn default() -> Self {
        TaskType::TASK_TYPE_UNSPECIFIED
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n2google/cloud/osconfig/agentendpoint/v1/tasks.proto\x12&google.cloud.o\
    sconfig.agentendpoint.v1\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19g\
    oogle/api/resource.proto\x1a:google/cloud/osconfig/agentendpoint/v1/conf\
    ig_common.proto\x1a6google/cloud/osconfig/agentendpoint/v1/os_policy.pro\
    to\x1a7google/cloud/osconfig/agentendpoint/v1/patch_jobs.proto\"\xb5\x05\
    \n\x04Task\x12\x17\n\x07task_id\x18\x01\x20\x01(\tR\x06taskId\x12M\n\tta\
    sk_type\x18\x02\x20\x01(\x0e20.google.cloud.osconfig.agentendpoint.v1.Ta\
    skTypeR\x08taskType\x12\\\n\x0etask_directive\x18\x03\x20\x01(\x0e25.goo\
    gle.cloud.osconfig.agentendpoint.v1.TaskDirectiveR\rtaskDirective\x12h\n\
    \x12apply_patches_task\x18\x04\x20\x01(\x0b28.google.cloud.osconfig.agen\
    tendpoint.v1.ApplyPatchesTaskH\0R\x10applyPatchesTask\x12\\\n\x0eexec_st\
    ep_task\x18\x05\x20\x01(\x0b24.google.cloud.osconfig.agentendpoint.v1.Ex\
    ecStepTaskH\0R\x0cexecStepTask\x12e\n\x11apply_config_task\x18\x07\x20\
    \x01(\x0b27.google.cloud.osconfig.agentendpoint.v1.ApplyConfigTaskH\0R\
    \x0fapplyConfigTask\x12f\n\x0eservice_labels\x18\x06\x20\x03(\x0b2?.goog\
    le.cloud.osconfig.agentendpoint.v1.Task.ServiceLabelsEntryR\rserviceLabe\
    ls\x1a@\n\x12ServiceLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03\
    key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01B\x0e\n\x0c\
    task_details\"\x83\x01\n\x10ApplyPatchesTask\x12V\n\x0cpatch_config\x18\
    \x01\x20\x01(\x0b23.google.cloud.osconfig.agentendpoint.v1.PatchConfigR\
    \x0bpatchConfig\x12\x17\n\x07dry_run\x18\x03\x20\x01(\x08R\x06dryRun\"\
    \xe8\x01\n\x18ApplyPatchesTaskProgress\x12a\n\x05state\x18\x01\x20\x01(\
    \x0e2F.google.cloud.osconfig.agentendpoint.v1.ApplyPatchesTaskProgress.S\
    tateR\x05stateB\x03\xe0A\x02\"i\n\x05State\x12\x15\n\x11STATE_UNSPECIFIE\
    D\x10\0\x12\x0b\n\x07STARTED\x10\x04\x12\x17\n\x13DOWNLOADING_PATCHES\
    \x10\x01\x12\x14\n\x10APPLYING_PATCHES\x10\x02\x12\r\n\tREBOOTING\x10\
    \x03\"\xd3\x01\n\x16ApplyPatchesTaskOutput\x12_\n\x05state\x18\x01\x20\
    \x01(\x0e2D.google.cloud.osconfig.agentendpoint.v1.ApplyPatchesTaskOutpu\
    t.StateR\x05stateB\x03\xe0A\x02\"X\n\x05State\x12\x15\n\x11STATE_UNSPECI\
    FIED\x10\0\x12\r\n\tSUCCEEDED\x10\x01\x12\x1d\n\x19SUCCEEDED_REBOOT_REQU\
    IRED\x10\x02\x12\n\n\x06FAILED\x10\x03\"]\n\x0cExecStepTask\x12M\n\texec\
    _step\x18\x01\x20\x01(\x0b20.google.cloud.osconfig.agentendpoint.v1.Exec\
    StepR\x08execStep\"\xa2\x01\n\x14ExecStepTaskProgress\x12]\n\x05state\
    \x18\x01\x20\x01(\x0e2B.google.cloud.osconfig.agentendpoint.v1.ExecStepT\
    askProgress.StateR\x05stateB\x03\xe0A\x02\"+\n\x05State\x12\x15\n\x11STA\
    TE_UNSPECIFIED\x10\0\x12\x0b\n\x07STARTED\x10\x01\"\xe0\x01\n\x12ExecSte\
    pTaskOutput\x12[\n\x05state\x18\x01\x20\x01(\x0e2@.google.cloud.osconfig\
    .agentendpoint.v1.ExecStepTaskOutput.StateR\x05stateB\x03\xe0A\x02\x12\
    \x20\n\texit_code\x18\x02\x20\x01(\x05R\x08exitCodeB\x03\xe0A\x02\"K\n\
    \x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\0\x12\r\n\tCOMPLETED\x10\
    \x01\x12\r\n\tTIMED_OUT\x10\x02\x12\r\n\tCANCELLED\x10\x03\"\x98\x03\n\
    \x0fApplyConfigTask\x12a\n\x0bos_policies\x18\x01\x20\x03(\x0b2@.google.\
    cloud.osconfig.agentendpoint.v1.ApplyConfigTask.OSPolicyR\nosPolicies\
    \x1a\xa1\x02\n\x08OSPolicy\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\
    I\n\x04mode\x18\x02\x20\x01(\x0e25.google.cloud.osconfig.agentendpoint.v\
    1.OSPolicy.ModeR\x04mode\x12a\n\x14os_policy_assignment\x18\x03\x20\x01(\
    \tR\x12osPolicyAssignmentB/\xfaA,\n*osconfig.googleapis.com/OSPolicyAssi\
    gnment\x12W\n\tresources\x18\x04\x20\x03(\x0b29.google.cloud.osconfig.ag\
    entendpoint.v1.OSPolicy.ResourceR\tresources\"\xb8\x01\n\x17ApplyConfigT\
    askProgress\x12[\n\x05state\x18\x01\x20\x01(\x0e2E.google.cloud.osconfig\
    .agentendpoint.v1.ApplyConfigTaskProgress.StateR\x05state\"@\n\x05State\
    \x12\x15\n\x11STATE_UNSPECIFIED\x10\0\x12\x0b\n\x07STARTED\x10\x01\x12\
    \x13\n\x0fAPPLYING_CONFIG\x10\x02\"\xdd\x04\n\x15ApplyConfigTaskOutput\
    \x12^\n\x05state\x18\x01\x20\x01(\x0e2C.google.cloud.osconfig.agentendpo\
    int.v1.ApplyConfigTaskOutput.StateR\x05stateB\x03\xe0A\x02\x12x\n\x11os_\
    policy_results\x18\x02\x20\x03(\x0b2L.google.cloud.osconfig.agentendpoin\
    t.v1.ApplyConfigTaskOutput.OSPolicyResultR\x0fosPolicyResults\x1a\x9f\
    \x02\n\x0eOSPolicyResult\x12\x20\n\x0cos_policy_id\x18\x01\x20\x01(\tR\n\
    osPolicyId\x12a\n\x14os_policy_assignment\x18\x02\x20\x01(\tR\x12osPolic\
    yAssignmentB/\xfaA,\n*osconfig.googleapis.com/OSPolicyAssignment\x12\x87\
    \x01\n\x1eos_policy_resource_compliances\x18\x03\x20\x03(\x0b2B.google.c\
    loud.osconfig.agentendpoint.v1.OSPolicyResourceComplianceR\x1bosPolicyRe\
    sourceCompliances\"H\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\0\x12\
    \r\n\tSUCCEEDED\x10\x01\x12\n\n\x06FAILED\x10\x02\x12\r\n\tCANCELLED\x10\
    \x03*G\n\rTaskDirective\x12\x1e\n\x1aTASK_DIRECTIVE_UNSPECIFIED\x10\0\
    \x12\x0c\n\x08CONTINUE\x10\x01\x12\x08\n\x04STOP\x10\x02*c\n\x08TaskType\
    \x12\x19\n\x15TASK_TYPE_UNSPECIFIED\x10\0\x12\x11\n\rAPPLY_PATCHES\x10\
    \x01\x12\x12\n\x0eEXEC_STEP_TASK\x10\x02\x12\x15\n\x11APPLY_CONFIG_TASK\
    \x10\x03B\x8b\x02\n*com.google.cloud.osconfig.agentendpoint.v1B\x05Tasks\
    P\x01ZPcloud.google.com/go/osconfig/agentendpoint/apiv1/agentendpointpb;\
    agentendpointpb\xeaA\x80\x01\n*osconfig.googleapis.com/OSPolicyAssignmen\
    t\x12Rprojects/{project}/locations/{location}/osPolicyAssignments/{os_po\
    licy_assignment}J\xe7F\n\x07\x12\x05\x0e\0\x9d\x02\x01\n\xbc\x04\n\x01\
    \x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202020\x20Google\x20LLC\n\
    \n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\
    \x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\
    \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\
    y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\
    \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\
    ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\
    \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\
    buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\
    \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\
    \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\
    guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\
    e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0/\n\t\n\x02\x03\0\x12\x03\
    \x12\0)\n\t\n\x02\x03\x01\x12\x03\x13\0#\n\t\n\x02\x03\x02\x12\x03\x14\0\
    D\n\t\n\x02\x03\x03\x12\x03\x15\0@\n\t\n\x02\x03\x04\x12\x03\x16\0A\n\
    \x08\n\x01\x08\x12\x03\x18\0g\n\t\n\x02\x08\x0b\x12\x03\x18\0g\n\x08\n\
    \x01\x08\x12\x03\x19\0\"\n\t\n\x02\x08\n\x12\x03\x19\0\"\n\x08\n\x01\x08\
    \x12\x03\x1a\0&\n\t\n\x02\x08\x08\x12\x03\x1a\0&\n\x08\n\x01\x08\x12\x03\
    \x1b\0C\n\t\n\x02\x08\x01\x12\x03\x1b\0C\n\t\n\x01\x08\x12\x04\x1c\0\x1f\
    \x02\n\x0c\n\x04\x08\x9d\x08\0\x12\x04\x1c\0\x1f\x02\n3\n\x02\x05\0\x12\
    \x04\"\0-\x01\x1a'\x20Specifies\x20the\x20current\x20agent\x20behavior.\
    \n\n\n\n\x03\x05\0\x01\x12\x03\"\x05\x12\n&\n\x04\x05\0\x02\0\x12\x03$\
    \x02!\x1a\x19\x20Unspecified\x20is\x20invalid.\n\n\x0c\n\x05\x05\0\x02\0\
    \x01\x12\x03$\x02\x1c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03$\x1f\x20\n4\n\
    \x04\x05\0\x02\x01\x12\x03'\x02\x0f\x1a'\x20The\x20task\x20should\x20con\
    tinue\x20to\x20progress.\n\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03'\x02\n\
    \n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03'\r\x0e\n\xa9\x01\n\x04\x05\0\x02\
    \x02\x12\x03,\x02\x0b\x1a\x9b\x01\x20Task\x20should\x20not\x20be\x20star\
    ted,\x20or\x20if\x20already\x20in\x20progress,\x20should\x20stop\n\x20at\
    \x20first\x20safe\x20stopping\x20point.\x20\x20Task\x20should\x20be\x20c\
    onsidered\x20done\x20and\x20will\n\x20never\x20repeat.\n\n\x0c\n\x05\x05\
    \0\x02\x02\x01\x12\x03,\x02\x06\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03,\t\
    \n\n4\n\x02\x05\x01\x12\x040\0<\x01\x1a(\x20Specifies\x20the\x20type\x20\
    of\x20task\x20to\x20perform.\n\n\n\n\x03\x05\x01\x01\x12\x030\x05\r\n&\n\
    \x04\x05\x01\x02\0\x12\x032\x02\x1c\x1a\x19\x20Unspecified\x20is\x20inva\
    lid.\n\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x032\x02\x17\n\x0c\n\x05\x05\
    \x01\x02\0\x02\x12\x032\x1a\x1b\n&\n\x04\x05\x01\x02\x01\x12\x035\x02\
    \x14\x1a\x19\x20The\x20apply\x20patches\x20task.\n\n\x0c\n\x05\x05\x01\
    \x02\x01\x01\x12\x035\x02\x0f\n\x0c\n\x05\x05\x01\x02\x01\x02\x12\x035\
    \x12\x13\n\"\n\x04\x05\x01\x02\x02\x12\x038\x02\x15\x1a\x15\x20The\x20ex\
    ec\x20step\x20task.\n\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x038\x02\x10\n\
    \x0c\n\x05\x05\x01\x02\x02\x02\x12\x038\x13\x14\n$\n\x04\x05\x01\x02\x03\
    \x12\x03;\x02\x18\x1a\x17\x20The\x20apply\x20config\x20task\n\n\x0c\n\
    \x05\x05\x01\x02\x03\x01\x12\x03;\x02\x13\n\x0c\n\x05\x05\x01\x02\x03\
    \x02\x12\x03;\x16\x17\n:\n\x02\x04\0\x12\x04?\0]\x01\x1a.\x20A\x20unit\
    \x20of\x20work\x20to\x20be\x20performed\x20by\x20the\x20agent.\n\n\n\n\
    \x03\x04\0\x01\x12\x03?\x08\x0c\n\x1e\n\x04\x04\0\x02\0\x12\x03A\x02\x15\
    \x1a\x11\x20Unique\x20task\x20id.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03A\
    \x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03A\t\x10\n\x0c\n\x05\x04\0\
    \x02\0\x03\x12\x03A\x13\x14\n\xe9\x01\n\x04\x04\0\x02\x01\x12\x03J\x02\
    \x19\x1a\xdb\x01\x20The\x20type\x20of\x20task\x20to\x20perform.\n\n\x20T\
    ask\x20details\x20must\x20include\x20the\x20appropriate\x20message\x20ba\
    sed\x20on\x20this\x20enum\x20as\n\x20specified\x20below:\n\x20APPLY_PATC\
    HES\x20=\x20ApplyPatchesTask\n\x20EXEC_STEP\x20=\x20ExecStepTask\n\x20AP\
    PLY_CONFIG_TASK\x20=\x20ApplyConfigTask\n\n\x0c\n\x05\x04\0\x02\x01\x06\
    \x12\x03J\x02\n\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03J\x0b\x14\n\x0c\n\
    \x05\x04\0\x02\x01\x03\x12\x03J\x17\x18\n.\n\x04\x04\0\x02\x02\x12\x03M\
    \x02#\x1a!\x20Current\x20directive\x20to\x20the\x20agent.\n\n\x0c\n\x05\
    \x04\0\x02\x02\x06\x12\x03M\x02\x0f\n\x0c\n\x05\x04\0\x02\x02\x01\x12\
    \x03M\x10\x1e\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03M!\"\nC\n\x04\x04\0\
    \x08\0\x12\x04P\x02Y\x03\x1a5\x20Specific\x20details\x20about\x20the\x20\
    current\x20task\x20to\x20perform.\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03P\
    \x08\x14\n?\n\x04\x04\0\x02\x03\x12\x03R\x04,\x1a2\x20Details\x20about\
    \x20the\x20apply\x20patches\x20task\x20to\x20perform.\n\n\x0c\n\x05\x04\
    \0\x02\x03\x06\x12\x03R\x04\x14\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03R\
    \x15'\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03R*+\n;\n\x04\x04\0\x02\x04\
    \x12\x03U\x04$\x1a.\x20Details\x20about\x20the\x20exec\x20step\x20task\
    \x20to\x20perform.\n\n\x0c\n\x05\x04\0\x02\x04\x06\x12\x03U\x04\x10\n\
    \x0c\n\x05\x04\0\x02\x04\x01\x12\x03U\x11\x1f\n\x0c\n\x05\x04\0\x02\x04\
    \x03\x12\x03U\"#\nC\n\x04\x04\0\x02\x05\x12\x03X\x04*\x1a6\x20Details\
    \x20about\x20the\x20apply\x20config\x20step\x20task\x20to\x20perform.\n\
    \n\x0c\n\x05\x04\0\x02\x05\x06\x12\x03X\x04\x13\n\x0c\n\x05\x04\0\x02\
    \x05\x01\x12\x03X\x14%\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03X()\nJ\n\x04\
    \x04\0\x02\x06\x12\x03\\\x02)\x1a=\x20Labels\x20describing\x20the\x20tas\
    k.\x20\x20Used\x20for\x20logging\x20by\x20the\x20agent.\n\n\x0c\n\x05\
    \x04\0\x02\x06\x06\x12\x03\\\x02\x15\n\x0c\n\x05\x04\0\x02\x06\x01\x12\
    \x03\\\x16$\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03\\'(\n=\n\x02\x04\x01\
    \x12\x04`\0g\x01\x1a1\x20Message\x20which\x20instructs\x20agent\x20to\
    \x20apply\x20patches.\n\n\n\n\x03\x04\x01\x01\x12\x03`\x08\x18\nH\n\x04\
    \x04\x01\x02\0\x12\x03b\x02\x1f\x1a;\x20Specific\x20information\x20about\
    \x20how\x20patches\x20should\x20be\x20applied.\n\n\x0c\n\x05\x04\x01\x02\
    \0\x06\x12\x03b\x02\r\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03b\x0e\x1a\n\
    \x0c\n\x05\x04\x01\x02\0\x03\x12\x03b\x1d\x1e\n\x94\x01\n\x04\x04\x01\
    \x02\x01\x12\x03f\x02\x13\x1a\x86\x01\x20If\x20true,\x20the\x20agent\x20\
    will\x20report\x20its\x20status\x20as\x20it\x20goes\x20through\x20the\
    \x20motions\n\x20but\x20won't\x20actually\x20run\x20any\x20updates\x20or\
    \x20perform\x20any\x20reboots.\n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\
    f\x02\x06\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03f\x07\x0e\n\x0c\n\x05\
    \x04\x01\x02\x01\x03\x12\x03f\x11\x12\nS\n\x02\x04\x02\x12\x04j\0\x7f\
    \x01\x1aG\x20Information\x20reported\x20from\x20the\x20agent\x20about\
    \x20applying\x20patches\x20execution.\n\n\n\n\x03\x04\x02\x01\x12\x03j\
    \x08\x20\n<\n\x04\x04\x02\x04\0\x12\x04l\x02{\x03\x1a.\x20The\x20interme\
    diate\x20states\x20of\x20applying\x20patches.\n\n\x0c\n\x05\x04\x02\x04\
    \0\x01\x12\x03l\x07\x0c\n(\n\x06\x04\x02\x04\0\x02\0\x12\x03n\x04\x1a\
    \x1a\x19\x20Unspecified\x20is\x20invalid.\n\n\x0e\n\x07\x04\x02\x04\0\
    \x02\0\x01\x12\x03n\x04\x15\n\x0e\n\x07\x04\x02\x04\0\x02\0\x02\x12\x03n\
    \x18\x19\n6\n\x06\x04\x02\x04\0\x02\x01\x12\x03q\x04\x10\x1a'\x20The\x20\
    agent\x20has\x20started\x20the\x20patch\x20task.\n\n\x0e\n\x07\x04\x02\
    \x04\0\x02\x01\x01\x12\x03q\x04\x0b\n\x0e\n\x07\x04\x02\x04\0\x02\x01\
    \x02\x12\x03q\x0e\x0f\n<\n\x06\x04\x02\x04\0\x02\x02\x12\x03t\x04\x1c\
    \x1a-\x20The\x20agent\x20is\x20currently\x20downloading\x20patches.\n\n\
    \x0e\n\x07\x04\x02\x04\0\x02\x02\x01\x12\x03t\x04\x17\n\x0e\n\x07\x04\
    \x02\x04\0\x02\x02\x02\x12\x03t\x1a\x1b\n9\n\x06\x04\x02\x04\0\x02\x03\
    \x12\x03w\x04\x19\x1a*\x20The\x20agent\x20is\x20currently\x20applying\
    \x20patches.\n\n\x0e\n\x07\x04\x02\x04\0\x02\x03\x01\x12\x03w\x04\x14\n\
    \x0e\n\x07\x04\x02\x04\0\x02\x03\x02\x12\x03w\x17\x18\n?\n\x06\x04\x02\
    \x04\0\x02\x04\x12\x03z\x04\x12\x1a0\x20The\x20agent\x20is\x20currently\
    \x20rebooting\x20the\x20instance.\n\n\x0e\n\x07\x04\x02\x04\0\x02\x04\
    \x01\x12\x03z\x04\r\n\x0e\n\x07\x04\x02\x04\0\x02\x04\x02\x12\x03z\x10\
    \x11\nC\n\x04\x04\x02\x02\0\x12\x03~\x02;\x1a6\x20Required.\x20The\x20cu\
    rrent\x20state\x20of\x20this\x20patch\x20execution.\n\n\x0c\n\x05\x04\
    \x02\x02\0\x06\x12\x03~\x02\x07\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03~\
    \x08\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03~\x10\x11\n\x0c\n\x05\x04\
    \x02\x02\0\x08\x12\x03~\x12:\n\x0f\n\x08\x04\x02\x02\0\x08\x9c\x08\0\x12\
    \x03~\x139\nU\n\x02\x04\x03\x12\x06\x82\x01\0\x94\x01\x01\x1aG\x20Inform\
    ation\x20reported\x20from\x20the\x20agent\x20about\x20applying\x20patche\
    s\x20execution.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x82\x01\x08\x1e\n7\n\
    \x04\x04\x03\x04\0\x12\x06\x84\x01\x02\x90\x01\x03\x1a'\x20The\x20final\
    \x20states\x20of\x20applying\x20patches.\n\n\r\n\x05\x04\x03\x04\0\x01\
    \x12\x04\x84\x01\x07\x0c\n)\n\x06\x04\x03\x04\0\x02\0\x12\x04\x86\x01\
    \x04\x1a\x1a\x19\x20Unspecified\x20is\x20invalid.\n\n\x0f\n\x07\x04\x03\
    \x04\0\x02\0\x01\x12\x04\x86\x01\x04\x15\n\x0f\n\x07\x04\x03\x04\0\x02\0\
    \x02\x12\x04\x86\x01\x18\x19\n:\n\x06\x04\x03\x04\0\x02\x01\x12\x04\x89\
    \x01\x04\x12\x1a*\x20Applying\x20patches\x20completed\x20successfully.\n\
    \n\x0f\n\x07\x04\x03\x04\0\x02\x01\x01\x12\x04\x89\x01\x04\r\n\x0f\n\x07\
    \x04\x03\x04\0\x02\x01\x02\x12\x04\x89\x01\x10\x11\nT\n\x06\x04\x03\x04\
    \0\x02\x02\x12\x04\x8c\x01\x04\"\x1aD\x20Applying\x20patches\x20complete\
    d\x20successfully,\x20but\x20a\x20reboot\x20is\x20required.\n\n\x0f\n\
    \x07\x04\x03\x04\0\x02\x02\x01\x12\x04\x8c\x01\x04\x1d\n\x0f\n\x07\x04\
    \x03\x04\0\x02\x02\x02\x12\x04\x8c\x01\x20!\n*\n\x06\x04\x03\x04\0\x02\
    \x03\x12\x04\x8f\x01\x04\x0f\x1a\x1a\x20Applying\x20patches\x20failed.\n\
    \n\x0f\n\x07\x04\x03\x04\0\x02\x03\x01\x12\x04\x8f\x01\x04\n\n\x0f\n\x07\
    \x04\x03\x04\0\x02\x03\x02\x12\x04\x8f\x01\r\x0e\n7\n\x04\x04\x03\x02\0\
    \x12\x04\x93\x01\x02;\x1a)\x20Required.\x20The\x20final\x20state\x20of\
    \x20this\x20task.\n\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\x93\x01\x02\x07\
    \n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x93\x01\x08\r\n\r\n\x05\x04\x03\x02\
    \0\x03\x12\x04\x93\x01\x10\x11\n\r\n\x05\x04\x03\x02\0\x08\x12\x04\x93\
    \x01\x12:\n\x10\n\x08\x04\x03\x02\0\x08\x9c\x08\0\x12\x04\x93\x01\x139\n\
    O\n\x02\x04\x04\x12\x06\x97\x01\0\x9a\x01\x01\x1aA\x20Message\x20which\
    \x20instructs\x20agent\x20to\x20execute\x20the\x20following\x20command.\
    \n\n\x0b\n\x03\x04\x04\x01\x12\x04\x97\x01\x08\x14\n0\n\x04\x04\x04\x02\
    \0\x12\x04\x99\x01\x02\x19\x1a\"\x20Details\x20of\x20the\x20exec\x20step\
    \x20to\x20run.\n\n\r\n\x05\x04\x04\x02\0\x06\x12\x04\x99\x01\x02\n\n\r\n\
    \x05\x04\x04\x02\0\x01\x12\x04\x99\x01\x0b\x14\n\r\n\x05\x04\x04\x02\0\
    \x03\x12\x04\x99\x01\x17\x18\nR\n\x02\x04\x05\x12\x06\x9d\x01\0\xa9\x01\
    \x01\x1aD\x20Information\x20reported\x20from\x20the\x20agent\x20about\
    \x20the\x20exec\x20step\x20execution.\n\n\x0b\n\x03\x04\x05\x01\x12\x04\
    \x9d\x01\x08\x1c\n8\n\x04\x04\x05\x04\0\x12\x06\x9f\x01\x02\xa5\x01\x03\
    \x1a(\x20The\x20intermediate\x20states\x20of\x20exec\x20steps.\n\n\r\n\
    \x05\x04\x05\x04\0\x01\x12\x04\x9f\x01\x07\x0c\n)\n\x06\x04\x05\x04\0\
    \x02\0\x12\x04\xa1\x01\x04\x1a\x1a\x19\x20Unspecified\x20is\x20invalid.\
    \n\n\x0f\n\x07\x04\x05\x04\0\x02\0\x01\x12\x04\xa1\x01\x04\x15\n\x0f\n\
    \x07\x04\x05\x04\0\x02\0\x02\x12\x04\xa1\x01\x18\x19\n;\n\x06\x04\x05\
    \x04\0\x02\x01\x12\x04\xa4\x01\x04\x10\x1a+\x20The\x20agent\x20has\x20st\
    arted\x20the\x20exec\x20step\x20task.\n\n\x0f\n\x07\x04\x05\x04\0\x02\
    \x01\x01\x12\x04\xa4\x01\x04\x0b\n\x0f\n\x07\x04\x05\x04\0\x02\x01\x02\
    \x12\x04\xa4\x01\x0e\x0f\n>\n\x04\x04\x05\x02\0\x12\x04\xa8\x01\x02;\x1a\
    0\x20Required.\x20The\x20current\x20state\x20of\x20this\x20exec\x20step.\
    \n\n\r\n\x05\x04\x05\x02\0\x06\x12\x04\xa8\x01\x02\x07\n\r\n\x05\x04\x05\
    \x02\0\x01\x12\x04\xa8\x01\x08\r\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\xa8\
    \x01\x10\x11\n\r\n\x05\x04\x05\x02\0\x08\x12\x04\xa8\x01\x12:\n\x10\n\
    \x08\x04\x05\x02\0\x08\x9c\x08\0\x12\x04\xa8\x01\x139\nR\n\x02\x04\x06\
    \x12\x06\xac\x01\0\xc1\x01\x01\x1aD\x20Information\x20reported\x20from\
    \x20the\x20agent\x20about\x20the\x20exec\x20step\x20execution.\n\n\x0b\n\
    \x03\x04\x06\x01\x12\x04\xac\x01\x08\x1a\n1\n\x04\x04\x06\x04\0\x12\x06\
    \xae\x01\x02\xba\x01\x03\x1a!\x20The\x20final\x20states\x20of\x20exec\
    \x20steps.\n\n\r\n\x05\x04\x06\x04\0\x01\x12\x04\xae\x01\x07\x0c\n)\n\
    \x06\x04\x06\x04\0\x02\0\x12\x04\xb0\x01\x04\x1a\x1a\x19\x20Unspecified\
    \x20is\x20invalid.\n\n\x0f\n\x07\x04\x06\x04\0\x02\0\x01\x12\x04\xb0\x01\
    \x04\x15\n\x0f\n\x07\x04\x06\x04\0\x02\0\x02\x12\x04\xb0\x01\x18\x19\n3\
    \n\x06\x04\x06\x04\0\x02\x01\x12\x04\xb3\x01\x04\x12\x1a#\x20The\x20exec\
    \x20step\x20completed\x20normally.\n\n\x0f\n\x07\x04\x06\x04\0\x02\x01\
    \x01\x12\x04\xb3\x01\x04\r\n\x0f\n\x07\x04\x06\x04\0\x02\x01\x02\x12\x04\
    \xb3\x01\x10\x11\nH\n\x06\x04\x06\x04\0\x02\x02\x12\x04\xb6\x01\x04\x12\
    \x1a8\x20The\x20exec\x20step\x20was\x20terminated\x20because\x20it\x20to\
    ok\x20too\x20long.\n\n\x0f\n\x07\x04\x06\x04\0\x02\x02\x01\x12\x04\xb6\
    \x01\x04\r\n\x0f\n\x07\x04\x06\x04\0\x02\x02\x02\x12\x04\xb6\x01\x10\x11\
    \nE\n\x06\x04\x06\x04\0\x02\x03\x12\x04\xb9\x01\x04\x12\x1a5\x20The\x20e\
    xec\x20step\x20task\x20was\x20cancelled\x20before\x20it\x20started.\n\n\
    \x0f\n\x07\x04\x06\x04\0\x02\x03\x01\x12\x04\xb9\x01\x04\r\n\x0f\n\x07\
    \x04\x06\x04\0\x02\x03\x02\x12\x04\xb9\x01\x10\x11\n;\n\x04\x04\x06\x02\
    \0\x12\x04\xbd\x01\x02;\x1a-\x20Required.\x20The\x20final\x20state\x20of\
    \x20the\x20exec\x20step.\n\n\r\n\x05\x04\x06\x02\0\x06\x12\x04\xbd\x01\
    \x02\x07\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xbd\x01\x08\r\n\r\n\x05\x04\
    \x06\x02\0\x03\x12\x04\xbd\x01\x10\x11\n\r\n\x05\x04\x06\x02\0\x08\x12\
    \x04\xbd\x01\x12:\n\x10\n\x08\x04\x06\x02\0\x08\x9c\x08\0\x12\x04\xbd\
    \x01\x139\nd\n\x04\x04\x06\x02\x01\x12\x04\xc0\x01\x02?\x1aV\x20Required\
    .\x20The\x20exit\x20code\x20received\x20from\x20the\x20script\x20which\
    \x20ran\x20as\x20part\x20of\x20the\x20exec\x20step.\n\n\r\n\x05\x04\x06\
    \x02\x01\x05\x12\x04\xc0\x01\x02\x07\n\r\n\x05\x04\x06\x02\x01\x01\x12\
    \x04\xc0\x01\x08\x11\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xc0\x01\x14\
    \x15\n\r\n\x05\x04\x06\x02\x01\x08\x12\x04\xc0\x01\x16>\n\x10\n\x08\x04\
    \x06\x02\x01\x08\x9c\x08\0\x12\x04\xc0\x01\x17=\nb\n\x02\x04\x07\x12\x06\
    \xc5\x01\0\xdf\x01\x01\x1aT\x20Message\x20which\x20instructs\x20OS\x20Co\
    nfig\x20agent\x20to\x20apply\x20the\x20desired\x20state\n\x20configurati\
    on.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xc5\x01\x08\x17\n4\n\x04\x04\x07\
    \x03\0\x12\x06\xc7\x01\x02\xdb\x01\x03\x1a$\x20Message\x20representing\
    \x20an\x20OS\x20policy.\n\n\r\n\x05\x04\x07\x03\0\x01\x12\x04\xc7\x01\n\
    \x12\nX\n\x06\x04\x07\x03\0\x02\0\x12\x04\xca\x01\x04\x12\x1aH\x20User\
    \x20provided\x20policy\x20id.\n\x20Used\x20for\x20reporting\x20and\x20lo\
    gging\x20by\x20the\x20agent.\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x05\x12\
    \x04\xca\x01\x04\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x01\x12\x04\xca\x01\
    \x0b\r\n\x0f\n\x07\x04\x07\x03\0\x02\0\x03\x12\x04\xca\x01\x10\x11\n!\n\
    \x06\x04\x07\x03\0\x02\x01\x12\x04\xcd\x01\x04C\x1a\x11\x20The\x20policy\
    \x20mode\n\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x06\x12\x04\xcd\x01\x049\n\
    \x0f\n\x07\x04\x07\x03\0\x02\x01\x01\x12\x04\xcd\x01:>\n\x0f\n\x07\x04\
    \x07\x03\0\x02\x01\x03\x12\x04\xcd\x01AB\n\x8a\x02\n\x06\x04\x07\x03\0\
    \x02\x02\x12\x06\xd4\x01\x04\xd6\x01(\x1a\xf7\x01\x20Reference\x20to\x20\
    the\x20`OSPolicyAssignment`\x20API\x20resource\x20that\x20this\x20`OSPol\
    icy`\n\x20belongs\x20to.\n\x20Format:\n\x20projects/{project_number}/loc\
    ations/{location}/osPolicyAssignments/{os_policy_assignment_id@revision_\
    id}\n\x20Used\x20for\x20reporting\x20and\x20logging\x20by\x20the\x20agen\
    t.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x02\x05\x12\x04\xd4\x01\x04\n\n\x0f\n\
    \x07\x04\x07\x03\0\x02\x02\x01\x12\x04\xd4\x01\x0b\x1f\n\x0f\n\x07\x04\
    \x07\x03\0\x02\x02\x03\x12\x04\xd4\x01\"#\n\x11\n\x07\x04\x07\x03\0\x02\
    \x02\x08\x12\x06\xd4\x01$\xd6\x01'\n\x13\n\t\x04\x07\x03\0\x02\x02\x08\
    \x9f\x08\x12\x06\xd4\x01%\xd6\x01&\na\n\x06\x04\x07\x03\0\x02\x03\x12\
    \x04\xda\x01\x04U\x1aQ\x20List\x20of\x20resources\x20associated\x20with\
    \x20the\x20policy\x20to\x20be\x20set\x20to\x20their\n\x20desired\x20stat\
    e.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x03\x04\x12\x04\xda\x01\x04\x0c\n\x0f\
    \n\x07\x04\x07\x03\0\x02\x03\x06\x12\x04\xda\x01\rF\n\x0f\n\x07\x04\x07\
    \x03\0\x02\x03\x01\x12\x04\xda\x01GP\n\x0f\n\x07\x04\x07\x03\0\x02\x03\
    \x03\x12\x04\xda\x01ST\nC\n\x04\x04\x07\x02\0\x12\x04\xde\x01\x02$\x1a5\
    \x20List\x20of\x20os\x20policies\x20to\x20be\x20applied\x20for\x20the\
    \x20instance.\n\n\r\n\x05\x04\x07\x02\0\x04\x12\x04\xde\x01\x02\n\n\r\n\
    \x05\x04\x07\x02\0\x06\x12\x04\xde\x01\x0b\x13\n\r\n\x05\x04\x07\x02\0\
    \x01\x12\x04\xde\x01\x14\x1f\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xde\x01\
    \"#\n\x80\x01\n\x02\x04\x08\x12\x06\xe3\x01\0\xf2\x01\x01\x1ar\x20Inform\
    ation\x20reported\x20from\x20the\x20agent\x20regarding\x20the\x20progres\
    s\x20of\x20the\x20task\x20of\n\x20applying\x20desired\x20state\x20config\
    uration.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xe3\x01\x08\x1f\n?\n\x04\x04\
    \x08\x04\0\x12\x06\xe5\x01\x02\xee\x01\x03\x1a/\x20The\x20intermediate\
    \x20states\x20of\x20apply\x20config\x20task.\n\n\r\n\x05\x04\x08\x04\0\
    \x01\x12\x04\xe5\x01\x07\x0c\n\x1f\n\x06\x04\x08\x04\0\x02\0\x12\x04\xe7\
    \x01\x04\x1a\x1a\x0f\x20Invalid\x20state\n\n\x0f\n\x07\x04\x08\x04\0\x02\
    \0\x01\x12\x04\xe7\x01\x04\x15\n\x0f\n\x07\x04\x08\x04\0\x02\0\x02\x12\
    \x04\xe7\x01\x18\x19\n1\n\x06\x04\x08\x04\0\x02\x01\x12\x04\xea\x01\x04\
    \x10\x1a!\x20The\x20agent\x20has\x20started\x20the\x20task.\n\n\x0f\n\
    \x07\x04\x08\x04\0\x02\x01\x01\x12\x04\xea\x01\x04\x0b\n\x0f\n\x07\x04\
    \x08\x04\0\x02\x01\x02\x12\x04\xea\x01\x0e\x0f\nL\n\x06\x04\x08\x04\0\
    \x02\x02\x12\x04\xed\x01\x04\x18\x1a<\x20The\x20agent\x20is\x20in\x20the\
    \x20process\x20of\x20applying\x20the\x20configuration.\n\n\x0f\n\x07\x04\
    \x08\x04\0\x02\x02\x01\x12\x04\xed\x01\x04\x13\n\x0f\n\x07\x04\x08\x04\0\
    \x02\x02\x02\x12\x04\xed\x01\x16\x17\n/\n\x04\x04\x08\x02\0\x12\x04\xf1\
    \x01\x02\x12\x1a!\x20The\x20current\x20state\x20of\x20this\x20task.\n\n\
    \r\n\x05\x04\x08\x02\0\x06\x12\x04\xf1\x01\x02\x07\n\r\n\x05\x04\x08\x02\
    \0\x01\x12\x04\xf1\x01\x08\r\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xf1\x01\
    \x10\x11\n~\n\x02\x04\t\x12\x06\xf6\x01\0\x9d\x02\x01\x1ap\x20Informatio\
    n\x20reported\x20from\x20the\x20agent\x20regarding\x20the\x20output\x20o\
    f\x20the\x20task\x20of\n\x20applying\x20desired\x20state\x20configuratio\
    n.\n\n\x0b\n\x03\x04\t\x01\x12\x04\xf6\x01\x08\x1d\nK\n\x04\x04\t\x03\0\
    \x12\x06\xf8\x01\x02\x87\x02\x03\x1a;\x20Result\x20of\x20applying\x20des\
    ired\x20state\x20config\x20for\x20an\x20OS\x20policy.\n\n\r\n\x05\x04\t\
    \x03\0\x01\x12\x04\xf8\x01\n\x18\n\"\n\x06\x04\t\x03\0\x02\0\x12\x04\xfa\
    \x01\x04\x1c\x1a\x12\x20The\x20OS\x20policy\x20id\n\n\x0f\n\x07\x04\t\
    \x03\0\x02\0\x05\x12\x04\xfa\x01\x04\n\n\x0f\n\x07\x04\t\x03\0\x02\0\x01\
    \x12\x04\xfa\x01\x0b\x17\n\x0f\n\x07\x04\t\x03\0\x02\0\x03\x12\x04\xfa\
    \x01\x1a\x1b\n\x8a\x02\n\x06\x04\t\x03\0\x02\x01\x12\x06\x81\x02\x04\x83\
    \x02(\x1a\xf7\x01\x20Reference\x20to\x20the\x20`OSPolicyAssignment`\x20A\
    PI\x20resource\x20that\x20this\x20`OSPolicy`\n\x20belongs\x20to.\n\x20Fo\
    rmat:\n\x20projects/{project_number}/locations/{location}/osPolicyAssign\
    ments/{os_policy_assignment_id@revision_id}\n\x20Used\x20for\x20reportin\
    g\x20and\x20logging\x20by\x20the\x20agent.\n\n\x0f\n\x07\x04\t\x03\0\x02\
    \x01\x05\x12\x04\x81\x02\x04\n\n\x0f\n\x07\x04\t\x03\0\x02\x01\x01\x12\
    \x04\x81\x02\x0b\x1f\n\x0f\n\x07\x04\t\x03\0\x02\x01\x03\x12\x04\x81\x02\
    \"#\n\x11\n\x07\x04\t\x03\0\x02\x01\x08\x12\x06\x81\x02$\x83\x02'\n\x13\
    \n\t\x04\t\x03\0\x02\x01\x08\x9f\x08\x12\x06\x81\x02%\x83\x02&\nW\n\x06\
    \x04\t\x03\0\x02\x02\x12\x04\x86\x02\x04K\x1aG\x20Results\x20of\x20apply\
    ing\x20desired\x20state\x20config\x20for\x20the\x20OS\x20policy\x20resou\
    rces.\n\n\x0f\n\x07\x04\t\x03\0\x02\x02\x04\x12\x04\x86\x02\x04\x0c\n\
    \x0f\n\x07\x04\t\x03\0\x02\x02\x06\x12\x04\x86\x02\r'\n\x0f\n\x07\x04\t\
    \x03\0\x02\x02\x01\x12\x04\x86\x02(F\n\x0f\n\x07\x04\t\x03\0\x02\x02\x03\
    \x12\x04\x86\x02IJ\n/\n\x04\x04\t\x04\0\x12\x06\x8a\x02\x02\x96\x02\x03\
    \x1a\x1f\x20The\x20final\x20state\x20of\x20this\x20task.\n\n\r\n\x05\x04\
    \t\x04\0\x01\x12\x04\x8a\x02\x07\x0c\n)\n\x06\x04\t\x04\0\x02\0\x12\x04\
    \x8c\x02\x04\x1a\x1a\x19\x20Unspecified\x20is\x20invalid.\n\n\x0f\n\x07\
    \x04\t\x04\0\x02\0\x01\x12\x04\x8c\x02\x04\x15\n\x0f\n\x07\x04\t\x04\0\
    \x02\0\x02\x12\x04\x8c\x02\x18\x19\n?\n\x06\x04\t\x04\0\x02\x01\x12\x04\
    \x8f\x02\x04\x12\x1a/\x20The\x20apply\x20config\x20task\x20completed\x20\
    successfully.\n\n\x0f\n\x07\x04\t\x04\0\x02\x01\x01\x12\x04\x8f\x02\x04\
    \r\n\x0f\n\x07\x04\t\x04\0\x02\x01\x02\x12\x04\x8f\x02\x10\x11\n/\n\x06\
    \x04\t\x04\0\x02\x02\x12\x04\x92\x02\x04\x0f\x1a\x1f\x20The\x20apply\x20\
    config\x20task\x20failed.\n\n\x0f\n\x07\x04\t\x04\0\x02\x02\x01\x12\x04\
    \x92\x02\x04\n\n\x0f\n\x07\x04\t\x04\0\x02\x02\x02\x12\x04\x92\x02\r\x0e\
    \n6\n\x06\x04\t\x04\0\x02\x03\x12\x04\x95\x02\x04\x12\x1a&\x20The\x20app\
    ly\x20config\x20task\x20was\x20cancelled.\n\n\x0f\n\x07\x04\t\x04\0\x02\
    \x03\x01\x12\x04\x95\x02\x04\r\n\x0f\n\x07\x04\t\x04\0\x02\x03\x02\x12\
    \x04\x95\x02\x10\x11\n7\n\x04\x04\t\x02\0\x12\x04\x99\x02\x02;\x1a)\x20R\
    equired.\x20The\x20final\x20state\x20of\x20this\x20task.\n\n\r\n\x05\x04\
    \t\x02\0\x06\x12\x04\x99\x02\x02\x07\n\r\n\x05\x04\t\x02\0\x01\x12\x04\
    \x99\x02\x08\r\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x99\x02\x10\x11\n\r\n\
    \x05\x04\t\x02\0\x08\x12\x04\x99\x02\x12:\n\x10\n\x08\x04\t\x02\0\x08\
    \x9c\x08\0\x12\x04\x99\x02\x139\nM\n\x04\x04\t\x02\x01\x12\x04\x9c\x02\
    \x020\x1a?\x20Results\x20of\x20applying\x20desired\x20state\x20config\
    \x20for\x20the\x20OS\x20policies.\n\n\r\n\x05\x04\t\x02\x01\x04\x12\x04\
    \x9c\x02\x02\n\n\r\n\x05\x04\t\x02\x01\x06\x12\x04\x9c\x02\x0b\x19\n\r\n\
    \x05\x04\t\x02\x01\x01\x12\x04\x9c\x02\x1a+\n\r\n\x05\x04\t\x02\x01\x03\
    \x12\x04\x9c\x02./b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}