/// An insight along with the information used to derive the insight. The insight
/// may have associated recommendations as well.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Insight {
    /// Name of the insight.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Free-form human readable summary in English. The maximum length is 500
    /// characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Fully qualified resource names that this insight is targeting.
    #[prost(string, repeated, tag = "9")]
    pub target_resources: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Insight subtype. Insight content schema will be stable for a given subtype.
    #[prost(string, tag = "10")]
    pub insight_subtype: ::prost::alloc::string::String,
    /// A struct of custom fields to explain the insight.
    /// Example: "grantedPermissionsCount": "1000"
    #[prost(message, optional, tag = "3")]
    pub content: ::core::option::Option<::prost_types::Struct>,
    /// Timestamp of the latest data used to generate the insight.
    #[prost(message, optional, tag = "4")]
    pub last_refresh_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Observation period that led to the insight. The source data used to
    /// generate the insight ends at last_refresh_time and begins at
    /// (last_refresh_time - observation_period).
    #[prost(message, optional, tag = "5")]
    pub observation_period: ::core::option::Option<::prost_types::Duration>,
    /// Information state and metadata.
    #[prost(message, optional, tag = "6")]
    pub state_info: ::core::option::Option<InsightStateInfo>,
    /// Category being targeted by the insight.
    #[prost(enumeration = "insight::Category", tag = "7")]
    pub category: i32,
    /// Insight's severity.
    #[prost(enumeration = "insight::Severity", tag = "15")]
    pub severity: i32,
    /// Fingerprint of the Insight. Provides optimistic locking when updating
    /// states.
    #[prost(string, tag = "11")]
    pub etag: ::prost::alloc::string::String,
    /// Recommendations derived from this insight.
    #[prost(message, repeated, tag = "8")]
    pub associated_recommendations: ::prost::alloc::vec::Vec<
        insight::RecommendationReference,
    >,
}
/// Nested message and enum types in `Insight`.
pub mod insight {
    /// Reference to an associated recommendation.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RecommendationReference {
        /// Recommendation resource name, e.g.
        /// projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]/recommendations/\[RECOMMENDATION_ID\]
        #[prost(string, tag = "1")]
        pub recommendation: ::prost::alloc::string::String,
    }
    /// Insight category.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Category {
        /// Unspecified category.
        Unspecified = 0,
        /// The insight is related to cost.
        Cost = 1,
        /// The insight is related to security.
        Security = 2,
        /// The insight is related to performance.
        Performance = 3,
        /// This insight is related to manageability.
        Manageability = 4,
    }
    impl Category {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Category::Unspecified => "CATEGORY_UNSPECIFIED",
                Category::Cost => "COST",
                Category::Security => "SECURITY",
                Category::Performance => "PERFORMANCE",
                Category::Manageability => "MANAGEABILITY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                "COST" => Some(Self::Cost),
                "SECURITY" => Some(Self::Security),
                "PERFORMANCE" => Some(Self::Performance),
                "MANAGEABILITY" => Some(Self::Manageability),
                _ => None,
            }
        }
    }
    /// Insight severity levels.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Severity {
        /// Insight has unspecified severity.
        Unspecified = 0,
        /// Insight has low severity.
        Low = 1,
        /// Insight has medium severity.
        Medium = 2,
        /// Insight has high severity.
        High = 3,
        /// Insight has critical severity.
        Critical = 4,
    }
    impl Severity {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Severity::Unspecified => "SEVERITY_UNSPECIFIED",
                Severity::Low => "LOW",
                Severity::Medium => "MEDIUM",
                Severity::High => "HIGH",
                Severity::Critical => "CRITICAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SEVERITY_UNSPECIFIED" => Some(Self::Unspecified),
                "LOW" => Some(Self::Low),
                "MEDIUM" => Some(Self::Medium),
                "HIGH" => Some(Self::High),
                "CRITICAL" => Some(Self::Critical),
                _ => None,
            }
        }
    }
}
/// Information related to insight state.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InsightStateInfo {
    /// Insight state.
    #[prost(enumeration = "insight_state_info::State", tag = "1")]
    pub state: i32,
    /// A map of metadata for the state, provided by user or automations systems.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `InsightStateInfo`.
pub mod insight_state_info {
    /// Represents insight state.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Unspecified state.
        Unspecified = 0,
        /// Insight is active. Content for ACTIVE insights can be updated by Google.
        /// ACTIVE insights can be marked DISMISSED OR ACCEPTED.
        Active = 1,
        /// Some action has been taken based on this insight. Insights become
        /// accepted when a recommendation derived from the insight has been marked
        /// CLAIMED, SUCCEEDED, or FAILED. ACTIVE insights can also be marked
        /// ACCEPTED explicitly. Content for ACCEPTED insights is immutable. ACCEPTED
        /// insights can only be marked ACCEPTED (which may update state metadata).
        Accepted = 2,
        /// Insight is dismissed. Content for DISMISSED insights can be updated by
        /// Google. DISMISSED insights can be marked as ACTIVE.
        Dismissed = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Active => "ACTIVE",
                State::Accepted => "ACCEPTED",
                State::Dismissed => "DISMISSED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "ACTIVE" => Some(Self::Active),
                "ACCEPTED" => Some(Self::Accepted),
                "DISMISSED" => Some(Self::Dismissed),
                _ => None,
            }
        }
    }
}
/// The type of insight.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InsightType {
    /// The insight_type’s name in format insightTypes/{insight_type}
    /// eg: insightTypes/google.iam.policy.Insight
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A recommendation along with a suggested action. E.g., a rightsizing
/// recommendation for an underutilized VM, IAM role recommendations, etc
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Recommendation {
    /// Name of recommendation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Free-form human readable summary in English. The maximum length is 500
    /// characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Contains an identifier for a subtype of recommendations produced for the
    /// same recommender. Subtype is a function of content and impact, meaning a
    /// new subtype might be added when significant changes to `content` or
    /// `primary_impact.category` are introduced. See the Recommenders section
    /// to see a list of subtypes for a given Recommender.
    ///
    /// Examples:
    ///    For recommender = "google.iam.policy.Recommender",
    ///    recommender_subtype can be one of "REMOVE_ROLE"/"REPLACE_ROLE"
    #[prost(string, tag = "12")]
    pub recommender_subtype: ::prost::alloc::string::String,
    /// Last time this recommendation was refreshed by the system that created it
    /// in the first place.
    #[prost(message, optional, tag = "4")]
    pub last_refresh_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The primary impact that this recommendation can have while trying to
    /// optimize for one category.
    #[prost(message, optional, tag = "5")]
    pub primary_impact: ::core::option::Option<Impact>,
    /// Optional set of additional impact that this recommendation may have when
    /// trying to optimize for the primary category. These may be positive
    /// or negative.
    #[prost(message, repeated, tag = "6")]
    pub additional_impact: ::prost::alloc::vec::Vec<Impact>,
    /// Recommendation's priority.
    #[prost(enumeration = "recommendation::Priority", tag = "17")]
    pub priority: i32,
    /// Content of the recommendation describing recommended changes to resources.
    #[prost(message, optional, tag = "7")]
    pub content: ::core::option::Option<RecommendationContent>,
    /// Information for state. Contains state and metadata.
    #[prost(message, optional, tag = "10")]
    pub state_info: ::core::option::Option<RecommendationStateInfo>,
    /// Fingerprint of the Recommendation. Provides optimistic locking when
    /// updating states.
    #[prost(string, tag = "11")]
    pub etag: ::prost::alloc::string::String,
    /// Insights that led to this recommendation.
    #[prost(message, repeated, tag = "14")]
    pub associated_insights: ::prost::alloc::vec::Vec<recommendation::InsightReference>,
    /// Corresponds to a mutually exclusive group ID within a recommender.
    /// A non-empty ID indicates that the recommendation belongs to a mutually
    /// exclusive group. This means that only one recommendation within the group
    /// is suggested to be applied.
    #[prost(string, tag = "18")]
    pub xor_group_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Recommendation`.
pub mod recommendation {
    /// Reference to an associated insight.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InsightReference {
        /// Insight resource name, e.g.
        /// projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]/insights/\[INSIGHT_ID\]
        #[prost(string, tag = "1")]
        pub insight: ::prost::alloc::string::String,
    }
    /// Recommendation priority levels.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Priority {
        /// Recommendation has unspecified priority.
        Unspecified = 0,
        /// Recommendation has P4 priority (lowest priority).
        P4 = 1,
        /// Recommendation has P3 priority (second lowest priority).
        P3 = 2,
        /// Recommendation has P2 priority (second highest priority).
        P2 = 3,
        /// Recommendation has P1 priority (highest priority).
        P1 = 4,
    }
    impl Priority {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Priority::Unspecified => "PRIORITY_UNSPECIFIED",
                Priority::P4 => "P4",
                Priority::P3 => "P3",
                Priority::P2 => "P2",
                Priority::P1 => "P1",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PRIORITY_UNSPECIFIED" => Some(Self::Unspecified),
                "P4" => Some(Self::P4),
                "P3" => Some(Self::P3),
                "P2" => Some(Self::P2),
                "P1" => Some(Self::P1),
                _ => None,
            }
        }
    }
}
/// Contains what resources are changing and how they are changing.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommendationContent {
    /// Operations to one or more Google Cloud resources grouped in such a way
    /// that, all operations within one group are expected to be performed
    /// atomically and in an order.
    #[prost(message, repeated, tag = "2")]
    pub operation_groups: ::prost::alloc::vec::Vec<OperationGroup>,
    /// Condensed overview information about the recommendation.
    #[prost(message, optional, tag = "3")]
    pub overview: ::core::option::Option<::prost_types::Struct>,
}
/// Group of operations that need to be performed atomically.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationGroup {
    /// List of operations across one or more resources that belong to this group.
    /// Loosely based on RFC6902 and should be performed in the order they appear.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<Operation>,
}
/// Contains an operation for a resource loosely based on the JSON-PATCH format
/// with support for:
///
/// * Custom filters for describing partial array patch.
/// * Extended path values for describing nested arrays.
/// * Custom fields for describing the resource for which the operation is being
///    described.
/// * Allows extension to custom operations not natively supported by RFC6902.
/// See <https://tools.ietf.org/html/rfc6902> for details on the original RFC.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Operation {
    /// Type of this operation. Contains one of 'add', 'remove', 'replace', 'move',
    /// 'copy', 'test' and 'custom' operations. This field is case-insensitive and
    /// always populated.
    #[prost(string, tag = "1")]
    pub action: ::prost::alloc::string::String,
    /// Type of GCP resource being modified/tested. This field is always populated.
    /// Example: cloudresourcemanager.googleapis.com/Project,
    /// compute.googleapis.com/Instance
    #[prost(string, tag = "2")]
    pub resource_type: ::prost::alloc::string::String,
    /// Contains the fully qualified resource name. This field is always populated.
    /// ex: //cloudresourcemanager.googleapis.com/projects/foo.
    #[prost(string, tag = "3")]
    pub resource: ::prost::alloc::string::String,
    /// Path to the target field being operated on. If the operation is at the
    /// resource level, then path should be "/". This field is always populated.
    #[prost(string, tag = "4")]
    pub path: ::prost::alloc::string::String,
    /// Can be set with action 'copy' to copy resource configuration across
    /// different resources of the same type. Example: A resource clone can be
    /// done via action = 'copy', path = "/", from = "/",
    /// source_resource = <source> and resource_name = <target>.
    /// This field is empty for all other values of `action`.
    #[prost(string, tag = "5")]
    pub source_resource: ::prost::alloc::string::String,
    /// Can be set with action 'copy' or 'move' to indicate the source field within
    /// resource or source_resource, ignored if provided for other operation types.
    #[prost(string, tag = "6")]
    pub source_path: ::prost::alloc::string::String,
    /// Set of filters to apply if `path` refers to array elements or nested array
    /// elements in order to narrow down to a single unique element that is being
    /// tested/modified.
    /// This is intended to be an exact match per filter. To perform advanced
    /// matching, use path_value_matchers.
    ///
    /// * Example:
    /// ```
    /// {
    ///    "/versions/*/name" : "it-123"
    ///    "/versions/*/targetSize/percent": 20
    /// }
    /// ```
    /// * Example:
    /// ```
    /// {
    ///    "/bindings/*/role": "roles/owner"
    ///    "/bindings/*/condition" : null
    /// }
    /// ```
    /// * Example:
    /// ```
    /// {
    ///    "/bindings/*/role": "roles/owner"
    ///    "/bindings/*/members/*" : \["x@example.com", "y@example.com"\]
    /// }
    /// ```
    /// When both path_filters and path_value_matchers are set, an implicit AND
    /// must be performed.
    #[prost(map = "string, message", tag = "8")]
    pub path_filters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost_types::Value,
    >,
    /// Similar to path_filters, this contains set of filters to apply if `path`
    /// field refers to array elements. This is meant to support value matching
    /// beyond exact match. To perform exact match, use path_filters.
    /// When both path_filters and path_value_matchers are set, an implicit AND
    /// must be performed.
    #[prost(map = "string, message", tag = "11")]
    pub path_value_matchers: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ValueMatcher,
    >,
    /// One of the fields in the following block will be set and intend to
    /// describe a value for 'path' field.
    #[prost(oneof = "operation::PathValue", tags = "7, 10")]
    pub path_value: ::core::option::Option<operation::PathValue>,
}
/// Nested message and enum types in `Operation`.
pub mod operation {
    /// One of the fields in the following block will be set and intend to
    /// describe a value for 'path' field.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PathValue {
        /// Value for the `path` field. Will be set for actions:'add'/'replace'.
        /// Maybe set for action: 'test'. Either this or `value_matcher` will be set
        /// for 'test' operation. An exact match must be performed.
        #[prost(message, tag = "7")]
        Value(::prost_types::Value),
        /// Can be set for action 'test' for advanced matching for the value of
        /// 'path' field. Either this or `value` will be set for 'test' operation.
        #[prost(message, tag = "10")]
        ValueMatcher(super::ValueMatcher),
    }
}
/// Contains various matching options for values for a GCP resource field.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ValueMatcher {
    #[prost(oneof = "value_matcher::MatchVariant", tags = "1")]
    pub match_variant: ::core::option::Option<value_matcher::MatchVariant>,
}
/// Nested message and enum types in `ValueMatcher`.
pub mod value_matcher {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum MatchVariant {
        /// To be used for full regex matching. The regular expression is using the
        /// Google RE2 syntax (<https://github.com/google/re2/wiki/Syntax>), so to be
        /// used with RE2::FullMatch
        #[prost(string, tag = "1")]
        MatchesPattern(::prost::alloc::string::String),
    }
}
/// Contains metadata about how much money a recommendation can save or incur.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CostProjection {
    /// An approximate projection on amount saved or amount incurred. Negative cost
    /// units indicate cost savings and positive cost units indicate increase.
    /// See google.type.Money documentation for positive/negative units.
    ///
    /// A user's permissions may affect whether the cost is computed using list
    /// prices or custom contract prices.
    #[prost(message, optional, tag = "1")]
    pub cost: ::core::option::Option<super::super::super::r#type::Money>,
    /// Duration for which this cost applies.
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
}
/// Contains various ways of describing the impact on Security.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecurityProjection {
    /// This field can be used by the recommender to define details specific to
    /// security impact.
    #[prost(message, optional, tag = "2")]
    pub details: ::core::option::Option<::prost_types::Struct>,
}
/// Contains metadata about how much sustainability a recommendation can save or
/// incur.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SustainabilityProjection {
    /// Carbon Footprint generated in kg of CO2 equivalent.
    /// Chose kg_c_o2e so that the name renders correctly in camelCase (kgCO2e).
    #[prost(double, tag = "1")]
    pub kg_c_o2e: f64,
    /// Duration for which this sustanability applies.
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
}
/// Contains the impact a recommendation can have for a given category.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Impact {
    /// Category that is being targeted.
    #[prost(enumeration = "impact::Category", tag = "1")]
    pub category: i32,
    /// Contains projections (if any) for this category.
    #[prost(oneof = "impact::Projection", tags = "100, 101, 102")]
    pub projection: ::core::option::Option<impact::Projection>,
}
/// Nested message and enum types in `Impact`.
pub mod impact {
    /// The category of the impact.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Category {
        /// Default unspecified category. Don't use directly.
        Unspecified = 0,
        /// Indicates a potential increase or decrease in cost.
        Cost = 1,
        /// Indicates a potential increase or decrease in security.
        Security = 2,
        /// Indicates a potential increase or decrease in performance.
        Performance = 3,
        /// Indicates a potential increase or decrease in manageability.
        Manageability = 4,
        /// Indicates a potential increase or decrease in sustainability.
        Sustainability = 5,
    }
    impl Category {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Category::Unspecified => "CATEGORY_UNSPECIFIED",
                Category::Cost => "COST",
                Category::Security => "SECURITY",
                Category::Performance => "PERFORMANCE",
                Category::Manageability => "MANAGEABILITY",
                Category::Sustainability => "SUSTAINABILITY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                "COST" => Some(Self::Cost),
                "SECURITY" => Some(Self::Security),
                "PERFORMANCE" => Some(Self::Performance),
                "MANAGEABILITY" => Some(Self::Manageability),
                "SUSTAINABILITY" => Some(Self::Sustainability),
                _ => None,
            }
        }
    }
    /// Contains projections (if any) for this category.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Projection {
        /// Use with CategoryType.COST
        #[prost(message, tag = "100")]
        CostProjection(super::CostProjection),
        /// Use with CategoryType.SECURITY
        #[prost(message, tag = "101")]
        SecurityProjection(super::SecurityProjection),
        /// Use with CategoryType.SUSTAINABILITY
        #[prost(message, tag = "102")]
        SustainabilityProjection(super::SustainabilityProjection),
    }
}
/// Information for state. Contains state and metadata.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommendationStateInfo {
    /// The state of the recommendation, Eg ACTIVE, SUCCEEDED, FAILED.
    #[prost(enumeration = "recommendation_state_info::State", tag = "1")]
    pub state: i32,
    /// A map of metadata for the state, provided by user or automations systems.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `RecommendationStateInfo`.
pub mod recommendation_state_info {
    /// Represents Recommendation State.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Default state. Don't use directly.
        Unspecified = 0,
        /// Recommendation is active and can be applied. Recommendations content can
        /// be updated by Google.
        ///
        /// ACTIVE recommendations can be marked as CLAIMED, SUCCEEDED, or FAILED.
        Active = 1,
        /// Recommendation is in claimed state. Recommendations content is
        /// immutable and cannot be updated by Google.
        ///
        /// CLAIMED recommendations can be marked as CLAIMED, SUCCEEDED, or FAILED.
        Claimed = 6,
        /// Recommendation is in succeeded state. Recommendations content is
        /// immutable and cannot be updated by Google.
        ///
        /// SUCCEEDED recommendations can be marked as SUCCEEDED, or FAILED.
        Succeeded = 3,
        /// Recommendation is in failed state. Recommendations content is immutable
        /// and cannot be updated by Google.
        ///
        /// FAILED recommendations can be marked as SUCCEEDED, or FAILED.
        Failed = 4,
        /// Recommendation is in dismissed state. Recommendation content can be
        /// updated by Google.
        ///
        /// DISMISSED recommendations can be marked as ACTIVE.
        Dismissed = 5,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Active => "ACTIVE",
                State::Claimed => "CLAIMED",
                State::Succeeded => "SUCCEEDED",
                State::Failed => "FAILED",
                State::Dismissed => "DISMISSED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "ACTIVE" => Some(Self::Active),
                "CLAIMED" => Some(Self::Claimed),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                "DISMISSED" => Some(Self::Dismissed),
                _ => None,
            }
        }
    }
}
/// The type of a recommender.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommenderType {
    /// The recommender's name in format RecommenderTypes/{recommender_type}
    /// eg:  recommenderTypes/google.iam.policy.Recommender
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Configuration for an InsightType.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InsightTypeConfig {
    /// Name of insight type config.
    /// Eg,
    /// projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]/config
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// InsightTypeGenerationConfig which configures the generation of
    /// insights for this insight type.
    #[prost(message, optional, tag = "2")]
    pub insight_type_generation_config: ::core::option::Option<
        InsightTypeGenerationConfig,
    >,
    /// Fingerprint of the InsightTypeConfig. Provides optimistic locking when
    /// updating.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Last time when the config was updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Immutable. The revision ID of the config.
    /// A new revision is committed whenever the config is changed in any way.
    /// The format is an 8-character hexadecimal string.
    #[prost(string, tag = "5")]
    pub revision_id: ::prost::alloc::string::String,
    /// Allows clients to store small amounts of arbitrary data. Annotations must
    /// follow the Kubernetes syntax.
    /// The total size of all keys and values combined is limited to 256k.
    /// Key can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    #[prost(map = "string, string", tag = "6")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// A user-settable field to provide a human-readable name to be used in user
    /// interfaces.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
}
/// A configuration to customize the generation of insights.
/// Eg, customizing the lookback period considered when generating a
/// insight.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InsightTypeGenerationConfig {
    /// Parameters for this InsightTypeGenerationConfig. These configs can be used
    /// by or are applied to all subtypes.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<::prost_types::Struct>,
}
/// Configuration for a Recommender.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommenderConfig {
    /// Name of recommender config.
    /// Eg,
    /// projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]/config
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// RecommenderGenerationConfig which configures the Generation of
    /// recommendations for this recommender.
    #[prost(message, optional, tag = "2")]
    pub recommender_generation_config: ::core::option::Option<
        RecommenderGenerationConfig,
    >,
    /// Fingerprint of the RecommenderConfig. Provides optimistic locking when
    /// updating.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Last time when the config was updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Immutable. The revision ID of the config.
    /// A new revision is committed whenever the config is changed in any way.
    /// The format is an 8-character hexadecimal string.
    #[prost(string, tag = "5")]
    pub revision_id: ::prost::alloc::string::String,
    /// Allows clients to store small amounts of arbitrary data. Annotations must
    /// follow the Kubernetes syntax.
    /// The total size of all keys and values combined is limited to 256k.
    /// Key can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    #[prost(map = "string, string", tag = "6")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// A user-settable field to provide a human-readable name to be used in user
    /// interfaces.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
}
/// A Configuration to customize the generation of recommendations.
/// Eg, customizing the lookback period considered when generating a
/// recommendation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommenderGenerationConfig {
    /// Parameters for this RecommenderGenerationConfig. These configs can be used
    /// by or are applied to all subtypes.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<::prost_types::Struct>,
}
/// Request for the `ListInsights` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInsightsRequest {
    /// Required. The container resource on which to execute the request.
    /// Acceptable formats:
    ///
    /// * `projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]`
    ///
    /// * `projects/\[PROJECT_ID\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]`
    ///
    /// * `billingAccounts/\[BILLING_ACCOUNT_ID\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]`
    ///
    /// * `folders/\[FOLDER_ID\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]`
    ///
    /// * `organizations/\[ORGANIZATION_ID\]/locations/\[LOCATION\]/insightTypes/\[INSIGHT_TYPE_ID\]`
    ///
    /// LOCATION here refers to GCP Locations:
    /// <https://cloud.google.com/about/locations/>
    /// INSIGHT_TYPE_ID refers to supported insight types:
    /// <https://cloud.google.com/recommender/docs/insights/insight-types.>
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return from this request.
    /// Non-positive values are ignored. If not specified, the server will
    /// determine the number of results to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. If present, retrieves the next batch of results from the
    /// preceding call to this method. `page_token` must be the value of
    /// `next_page_token` from the previous response. The values of other method
    /// parameters must be identical to those in the previous call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter expression to restrict the insights returned. Supported
    /// filter fields:
    ///
    /// * `stateInfo.state`
    ///
    /// * `insightSubtype`
    ///
    /// * `severity`
    ///
    /// Examples:
    ///
    /// * `stateInfo.state = ACTIVE OR stateInfo.state = DISMISSED`
    ///
    /// * `insightSubtype = PERMISSIONS_USAGE`
    ///
    /// * `severity = CRITICAL OR severity = HIGH`
    ///
    /// * `stateInfo.state = ACTIVE AND (severity = CRITICAL OR severity = HIGH)`
    ///
    /// (These expressions are based on the filter language described at
    /// <https://google.aip.dev/160>)
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response to the `ListInsights` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInsightsResponse {
    /// The set of insights for the `parent` resource.
    #[prost(message, repeated, tag = "1")]
    pub insights: ::prost::alloc::vec::Vec<Insight>,
    /// A token that can be used to request the next page of results. This field is
    /// empty if there are no additional results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request to the `GetInsight` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInsightRequest {
    /// Required. Name of the insight.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `MarkInsightAccepted` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MarkInsightAcceptedRequest {
    /// Required. Name of the insight.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. State properties user wish to include with this state.  Full
    /// replace of the current state_metadata.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Fingerprint of the Insight. Provides optimistic locking.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request for the `ListRecommendations` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRecommendationsRequest {
    /// Required. The container resource on which to execute the request.
    /// Acceptable formats:
    ///
    /// * `projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]`
    ///
    /// * `projects/\[PROJECT_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]`
    ///
    /// * `billingAccounts/\[BILLING_ACCOUNT_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]`
    ///
    /// * `folders/\[FOLDER_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]`
    ///
    /// * `organizations/\[ORGANIZATION_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]`
    ///
    /// LOCATION here refers to GCP Locations:
    /// <https://cloud.google.com/about/locations/>
    /// RECOMMENDER_ID refers to supported recommenders:
    /// <https://cloud.google.com/recommender/docs/recommenders.>
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return from this request.
    /// Non-positive values are ignored. If not specified, the server will
    /// determine the number of results to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. If present, retrieves the next batch of results from the
    /// preceding call to this method. `page_token` must be the value of
    /// `next_page_token` from the previous response. The values of other method
    /// parameters must be identical to those in the previous call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Filter expression to restrict the recommendations returned. Supported
    /// filter fields:
    ///
    /// * `state_info.state`
    ///
    /// * `recommenderSubtype`
    ///
    /// * `priority`
    ///
    /// Examples:
    ///
    /// * `stateInfo.state = ACTIVE OR stateInfo.state = DISMISSED`
    ///
    /// * `recommenderSubtype = REMOVE_ROLE OR recommenderSubtype = REPLACE_ROLE`
    ///
    /// * `priority = P1 OR priority = P2`
    ///
    /// * `stateInfo.state = ACTIVE AND (priority = P1 OR priority = P2)`
    ///
    /// (These expressions are based on the filter language described at
    /// <https://google.aip.dev/160>)
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// Response to the `ListRecommendations` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRecommendationsResponse {
    /// The set of recommendations for the `parent` resource.
    #[prost(message, repeated, tag = "1")]
    pub recommendations: ::prost::alloc::vec::Vec<Recommendation>,
    /// A token that can be used to request the next page of results. This field is
    /// empty if there are no additional results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request to the `GetRecommendation` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRecommendationRequest {
    /// Required. Name of the recommendation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `MarkRecommendationClaimed` Method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MarkRecommendationClaimedRequest {
    /// Required. Name of the recommendation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// State properties to include with this state. Overwrites any existing
    /// `state_metadata`.
    /// Keys must match the regex `/^[a-z0-9][a-z0-9_.-]{0,62}$/`.
    /// Values must match the regex `/^\[a-zA-Z0-9_./-\]{0,255}$/`.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Fingerprint of the Recommendation. Provides optimistic locking.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request for the `MarkRecommendationSucceeded` Method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MarkRecommendationSucceededRequest {
    /// Required. Name of the recommendation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// State properties to include with this state. Overwrites any existing
    /// `state_metadata`.
    /// Keys must match the regex `/^[a-z0-9][a-z0-9_.-]{0,62}$/`.
    /// Values must match the regex `/^\[a-zA-Z0-9_./-\]{0,255}$/`.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Fingerprint of the Recommendation. Provides optimistic locking.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request for the `MarkRecommendationFailed` Method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MarkRecommendationFailedRequest {
    /// Required. Name of the recommendation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// State properties to include with this state. Overwrites any existing
    /// `state_metadata`.
    /// Keys must match the regex `/^[a-z0-9][a-z0-9_.-]{0,62}$/`.
    /// Values must match the regex `/^\[a-zA-Z0-9_./-\]{0,255}$/`.
    #[prost(map = "string, string", tag = "2")]
    pub state_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Fingerprint of the Recommendation. Provides optimistic locking.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request for the GetRecommenderConfig` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRecommenderConfigRequest {
    /// Required. Name of the Recommendation Config to get.
    ///
    /// Acceptable formats:
    ///
    /// * `projects/\[PROJECT_NUMBER\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]/config`
    ///
    /// * `projects/\[PROJECT_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]/config`
    ///
    /// * `organizations/\[ORGANIZATION_ID\]/locations/\[LOCATION\]/recommenders/\[RECOMMENDER_ID\]/config`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `UpdateRecommenderConfig` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRecommenderConfigRequest {
    /// Required. The RecommenderConfig to update.
    #[prost(message, optional, tag = "1")]
    pub recommender_config: ::core::option::Option<RecommenderConfig>,
    /// The list of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// If true, validate the request and preview the change, but do not actually
    /// update it.
    #[prost(bool, tag = "3")]
    pub validate_only: bool,
}
/// Request for the GetInsightTypeConfig` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInsightTypeConfigRequest {
    /// Required. Name of the InsightTypeConfig to get.
    ///
    /// Acceptable formats:
    ///
    /// * `projects/\[PROJECT_NUMBER\]/locations/global/recommenders/\[INSIGHT_TYPE_ID\]/config`
    ///
    /// * `projects/\[PROJECT_ID\]/locations/global/recommenders/\[INSIGHT_TYPE_ID\]/config`
    ///
    /// * `organizations/\[ORGANIZATION_ID\]/locations/global/recommenders/\[INSIGHT_TYPE_ID\]/config`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `UpdateInsightTypeConfig` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateInsightTypeConfigRequest {
    /// Required. The InsightTypeConfig to update.
    #[prost(message, optional, tag = "1")]
    pub insight_type_config: ::core::option::Option<InsightTypeConfig>,
    /// The list of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// If true, validate the request and preview the change, but do not actually
    /// update it.
    #[prost(bool, tag = "3")]
    pub validate_only: bool,
}
/// Request for the `ListRecommender` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRecommendersRequest {
    /// The number of RecommenderTypes to return per page. The service may return
    /// fewer than this value.
    #[prost(int32, tag = "1")]
    pub page_size: i32,
    /// A page token, received from a previous `ListRecommenders` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response for the `ListRecommender` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRecommendersResponse {
    /// The set of recommenders available
    #[prost(message, repeated, tag = "1")]
    pub recommenders: ::prost::alloc::vec::Vec<RecommenderType>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request for the `ListInsightTypes` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInsightTypesRequest {
    /// The number of InsightTypes to return per page. The service may return
    /// fewer than this value.
    #[prost(int32, tag = "1")]
    pub page_size: i32,
    /// A page token, received from a previous `ListRecommenders` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response for the `ListInsightTypes` method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInsightTypesResponse {
    /// The set of recommenders available
    #[prost(message, repeated, tag = "1")]
    pub insight_types: ::prost::alloc::vec::Vec<InsightType>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod recommender_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Provides insights and recommendations for cloud customers for various
    /// categories like performance optimization, cost savings, reliability, feature
    /// discovery, etc. Insights and recommendations are generated automatically
    /// based on analysis of user resources, configuration and monitoring metrics.
    #[derive(Debug, Clone)]
    pub struct RecommenderClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RecommenderClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> RecommenderClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> RecommenderClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            RecommenderClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists insights for the specified Cloud Resource. Requires the
        /// recommender.*.list IAM permission for the specified insight type.
        pub async fn list_insights(
            &mut self,
            request: impl tonic::IntoRequest<super::ListInsightsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListInsightsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/ListInsights",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "ListInsights",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the requested insight. Requires the recommender.*.get IAM permission
        /// for the specified insight type.
        pub async fn get_insight(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInsightRequest>,
        ) -> std::result::Result<tonic::Response<super::Insight>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/GetInsight",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "GetInsight",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Marks the Insight State as Accepted. Users can use this method to
        /// indicate to the Recommender API that they have applied some action based
        /// on the insight. This stops the insight content from being updated.
        ///
        /// MarkInsightAccepted can be applied to insights in ACTIVE state. Requires
        /// the recommender.*.update IAM permission for the specified insight.
        pub async fn mark_insight_accepted(
            &mut self,
            request: impl tonic::IntoRequest<super::MarkInsightAcceptedRequest>,
        ) -> std::result::Result<tonic::Response<super::Insight>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/MarkInsightAccepted",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "MarkInsightAccepted",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists recommendations for the specified Cloud Resource. Requires the
        /// recommender.*.list IAM permission for the specified recommender.
        pub async fn list_recommendations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRecommendationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRecommendationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/ListRecommendations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "ListRecommendations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the requested recommendation. Requires the recommender.*.get
        /// IAM permission for the specified recommender.
        pub async fn get_recommendation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRecommendationRequest>,
        ) -> std::result::Result<tonic::Response<super::Recommendation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/GetRecommendation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "GetRecommendation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Marks the Recommendation State as Claimed. Users can use this method to
        /// indicate to the Recommender API that they are starting to apply the
        /// recommendation themselves. This stops the recommendation content from being
        /// updated. Associated insights are frozen and placed in the ACCEPTED state.
        ///
        /// MarkRecommendationClaimed can be applied to recommendations in CLAIMED or
        /// ACTIVE state.
        ///
        /// Requires the recommender.*.update IAM permission for the specified
        /// recommender.
        pub async fn mark_recommendation_claimed(
            &mut self,
            request: impl tonic::IntoRequest<super::MarkRecommendationClaimedRequest>,
        ) -> std::result::Result<tonic::Response<super::Recommendation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationClaimed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "MarkRecommendationClaimed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Marks the Recommendation State as Succeeded. Users can use this method to
        /// indicate to the Recommender API that they have applied the recommendation
        /// themselves, and the operation was successful. This stops the recommendation
        /// content from being updated. Associated insights are frozen and placed in
        /// the ACCEPTED state.
        ///
        /// MarkRecommendationSucceeded can be applied to recommendations in ACTIVE,
        /// CLAIMED, SUCCEEDED, or FAILED state.
        ///
        /// Requires the recommender.*.update IAM permission for the specified
        /// recommender.
        pub async fn mark_recommendation_succeeded(
            &mut self,
            request: impl tonic::IntoRequest<super::MarkRecommendationSucceededRequest>,
        ) -> std::result::Result<tonic::Response<super::Recommendation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationSucceeded",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "MarkRecommendationSucceeded",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Marks the Recommendation State as Failed. Users can use this method to
        /// indicate to the Recommender API that they have applied the recommendation
        /// themselves, and the operation failed. This stops the recommendation content
        /// from being updated. Associated insights are frozen and placed in the
        /// ACCEPTED state.
        ///
        /// MarkRecommendationFailed can be applied to recommendations in ACTIVE,
        /// CLAIMED, SUCCEEDED, or FAILED state.
        ///
        /// Requires the recommender.*.update IAM permission for the specified
        /// recommender.
        pub async fn mark_recommendation_failed(
            &mut self,
            request: impl tonic::IntoRequest<super::MarkRecommendationFailedRequest>,
        ) -> std::result::Result<tonic::Response<super::Recommendation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationFailed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "MarkRecommendationFailed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the requested Recommender Config. There is only one instance of the
        /// config for each Recommender.
        pub async fn get_recommender_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRecommenderConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RecommenderConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/GetRecommenderConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "GetRecommenderConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a Recommender Config. This will create a new revision of the
        /// config.
        pub async fn update_recommender_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateRecommenderConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RecommenderConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/UpdateRecommenderConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "UpdateRecommenderConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the requested InsightTypeConfig. There is only one instance of the
        /// config for each InsightType.
        pub async fn get_insight_type_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInsightTypeConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::InsightTypeConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/GetInsightTypeConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "GetInsightTypeConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an InsightTypeConfig change. This will create a new revision of the
        /// config.
        pub async fn update_insight_type_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateInsightTypeConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::InsightTypeConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/UpdateInsightTypeConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "UpdateInsightTypeConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all available Recommenders.
        /// No IAM permissions are required.
        pub async fn list_recommenders(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRecommendersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRecommendersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/ListRecommenders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "ListRecommenders",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists available InsightTypes.
        /// No IAM permissions are required.
        pub async fn list_insight_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListInsightTypesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListInsightTypesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.recommender.v1beta1.Recommender/ListInsightTypes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.recommender.v1beta1.Recommender",
                        "ListInsightTypes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
