// This file is @generated by prost-build.
/// A representation of the Channel resource.
/// A Channel is a resource on which event providers publish their events.
/// The published events are delivered through the transport associated with the
/// channel. Note that a channel is associated with exactly one event provider.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Channel {
    /// Required. The resource name of the channel. Must be unique within the
    /// location on the project and must be in
    /// `projects/{project}/locations/{location}/channels/{channel_id}` format.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server assigned unique identifier for the channel. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "6")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The name of the event provider (e.g. Eventarc SaaS partner) associated
    /// with the channel. This provider will be granted permissions to publish
    /// events to the channel. Format:
    /// `projects/{project}/locations/{location}/providers/{provider_id}`.
    #[prost(string, tag = "7")]
    pub provider: ::prost::alloc::string::String,
    /// Output only. The state of a Channel.
    #[prost(enumeration = "channel::State", tag = "9")]
    pub state: i32,
    /// Output only. The activation token for the channel. The token must be used
    /// by the provider to register the channel for publishing.
    #[prost(string, tag = "10")]
    pub activation_token: ::prost::alloc::string::String,
    /// Resource name of a KMS crypto key (managed by the user) used to
    /// encrypt/decrypt their event data.
    ///
    /// It must match the pattern
    /// `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
    #[prost(string, tag = "11")]
    pub crypto_key_name: ::prost::alloc::string::String,
    /// Output only. Whether or not this Channel satisfies the requirements of
    /// physical zone separation
    #[prost(bool, tag = "12")]
    pub satisfies_pzs: bool,
    #[prost(oneof = "channel::Transport", tags = "8")]
    pub transport: ::core::option::Option<channel::Transport>,
}
/// Nested message and enum types in `Channel`.
pub mod channel {
    /// State lists all the possible states of a Channel
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Default value. This value is unused.
        Unspecified = 0,
        /// The PENDING state indicates that a Channel has been created successfully
        /// and there is a new activation token available for the subscriber to use
        /// to convey the Channel to the provider in order to create a Connection.
        Pending = 1,
        /// The ACTIVE state indicates that a Channel has been successfully
        /// connected with the event provider.
        /// An ACTIVE Channel is ready to receive and route events from the
        /// event provider.
        Active = 2,
        /// The INACTIVE state indicates that the Channel cannot receive events
        /// permanently. There are two possible cases this state can happen:
        ///
        /// 1. The SaaS provider disconnected from this Channel.
        /// 1. The Channel activation token has expired but the SaaS provider
        ///    wasn't connected.
        ///
        /// To re-establish a Connection with a provider, the subscriber
        /// should create a new Channel and give it to the provider.
        Inactive = 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 {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Pending => "PENDING",
                Self::Active => "ACTIVE",
                Self::Inactive => "INACTIVE",
            }
        }
        /// 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),
                "PENDING" => Some(Self::Pending),
                "ACTIVE" => Some(Self::Active),
                "INACTIVE" => Some(Self::Inactive),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Transport {
        /// Output only. The name of the Pub/Sub topic created and managed by
        /// Eventarc system as a transport for the event delivery. Format:
        /// `projects/{project}/topics/{topic_id}`.
        #[prost(string, tag = "8")]
        PubsubTopic(::prost::alloc::string::String),
    }
}
/// A representation of the ChannelConnection resource.
/// A ChannelConnection is a resource which event providers create during the
/// activation process to establish a connection between the provider and the
/// subscriber channel.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChannelConnection {
    /// Required. The name of the connection.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server assigned ID of the resource.
    /// The server guarantees uniqueness and immutability until deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Required. The name of the connected subscriber Channel.
    /// This is a weak reference to avoid cross project and cross accounts
    /// references. This must be in
    /// `projects/{project}/location/{location}/channels/{channel_id}` format.
    #[prost(string, tag = "5")]
    pub channel: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "7")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Input only. Activation token for the channel. The token will be used
    /// during the creation of ChannelConnection to bind the channel with the
    /// provider project. This field will not be stored in the provider resource.
    #[prost(string, tag = "8")]
    pub activation_token: ::prost::alloc::string::String,
}
/// A representation of the Provider resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Provider {
    /// Output only. In
    /// `projects/{project}/locations/{location}/providers/{provider_id}` format.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Human friendly name for the Provider. For example "Cloud
    /// Storage".
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Event types for this provider.
    #[prost(message, repeated, tag = "3")]
    pub event_types: ::prost::alloc::vec::Vec<EventType>,
}
/// A representation of the event type resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventType {
    /// Output only. The full name of the event type (for example,
    /// "google.cloud.storage.object.v1.finalized"). In the form of
    /// {provider-specific-prefix}.{resource}.{version}.{verb}. Types MUST be
    /// versioned and event schemas are guaranteed to remain backward compatible
    /// within one version. Note that event type versions and API versions do not
    /// need to match.
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Output only. Human friendly description of what the event type is about.
    /// For example "Bucket created in Cloud Storage".
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Filtering attributes for the event type.
    #[prost(message, repeated, tag = "3")]
    pub filtering_attributes: ::prost::alloc::vec::Vec<FilteringAttribute>,
    /// Output only. URI for the event schema.
    /// For example
    /// "<https://github.com/googleapis/google-cloudevents/blob/master/proto/google/events/cloud/storage/v1/events.proto">
    #[prost(string, tag = "4")]
    pub event_schema_uri: ::prost::alloc::string::String,
}
/// A representation of the FilteringAttribute resource.
/// Filtering attributes are per event type.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FilteringAttribute {
    /// Output only. Attribute used for filtering the event type.
    #[prost(string, tag = "1")]
    pub attribute: ::prost::alloc::string::String,
    /// Output only. Description of the purpose of the attribute.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output only. If true, the triggers for this provider should always specify
    /// a filter on these attributes. Trigger creation will fail otherwise.
    #[prost(bool, tag = "3")]
    pub required: bool,
    /// Output only. If true, the attribute accepts matching expressions in the
    /// Eventarc PathPattern format.
    #[prost(bool, tag = "4")]
    pub path_pattern_supported: bool,
}
/// An enrollment represents a subscription for messages on a particular message
/// bus. It defines a matching criteria for messages on the bus and the
/// subscriber endpoint where matched messages should be delivered.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Enrollment {
    /// Identifier. Resource name of the form
    /// projects/{project}/locations/{location}/enrollments/{enrollment}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server assigned unique identifier for the channel. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Output only. This checksum is computed by the server based on the value of
    /// other fields, and might be sent only on update and delete requests to
    /// ensure that the client has an up-to-date value before proceeding.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Resource labels.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource annotations.
    #[prost(map = "string, string", tag = "7")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource display name.
    #[prost(string, tag = "8")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. A CEL expression identifying which messages this enrollment
    /// applies to.
    #[prost(string, tag = "9")]
    pub cel_match: ::prost::alloc::string::String,
    /// Required. Resource name of the message bus identifying the source of the
    /// messages. It matches the form
    /// projects/{project}/locations/{location}/messageBuses/{messageBus}.
    #[prost(string, tag = "10")]
    pub message_bus: ::prost::alloc::string::String,
    /// Required. Destination is the Pipeline that the Enrollment is delivering to.
    /// It must point to the full resource name of a Pipeline. Format:
    /// "projects/{PROJECT_ID}/locations/{region}/pipelines/{PIPELINE_ID)"
    #[prost(string, tag = "11")]
    pub destination: ::prost::alloc::string::String,
}
/// The configuration for Platform Telemetry logging for Eventarc Advanced
/// resources.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoggingConfig {
    /// Optional. The minimum severity of logs that will be sent to
    /// Stackdriver/Platform Telemetry. Logs at severitiy ≥ this value will be
    /// sent, unless it is NONE.
    #[prost(enumeration = "logging_config::LogSeverity", tag = "1")]
    pub log_severity: i32,
}
/// Nested message and enum types in `LoggingConfig`.
pub mod logging_config {
    /// The different severities for logging supported by Eventarc Advanced
    /// resources.
    /// This enum is an exhaustive list of log severities and is FROZEN. Do not
    /// expect new values to be added.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LogSeverity {
        /// Log severity is not specified. This value is treated the same as NONE,
        /// but is used to distinguish between no update and update to NONE in
        /// update_masks.
        Unspecified = 0,
        /// Default value at resource creation, presence of this value must be
        /// treated as no logging/disable logging.
        None = 1,
        /// Debug or trace level logging.
        Debug = 2,
        /// Routine information, such as ongoing status or performance.
        Info = 3,
        /// Normal but significant events, such as start up, shut down, or a
        /// configuration change.
        Notice = 4,
        /// Warning events might cause problems.
        Warning = 5,
        /// Error events are likely to cause problems.
        Error = 6,
        /// Critical events cause more severe problems or outages.
        Critical = 7,
        /// A person must take action immediately.
        Alert = 8,
        /// One or more systems are unusable.
        Emergency = 9,
    }
    impl LogSeverity {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "LOG_SEVERITY_UNSPECIFIED",
                Self::None => "NONE",
                Self::Debug => "DEBUG",
                Self::Info => "INFO",
                Self::Notice => "NOTICE",
                Self::Warning => "WARNING",
                Self::Error => "ERROR",
                Self::Critical => "CRITICAL",
                Self::Alert => "ALERT",
                Self::Emergency => "EMERGENCY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LOG_SEVERITY_UNSPECIFIED" => Some(Self::Unspecified),
                "NONE" => Some(Self::None),
                "DEBUG" => Some(Self::Debug),
                "INFO" => Some(Self::Info),
                "NOTICE" => Some(Self::Notice),
                "WARNING" => Some(Self::Warning),
                "ERROR" => Some(Self::Error),
                "CRITICAL" => Some(Self::Critical),
                "ALERT" => Some(Self::Alert),
                "EMERGENCY" => Some(Self::Emergency),
                _ => None,
            }
        }
    }
}
/// A GoogleApiSource represents a subscription of 1P events from a MessageBus.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GoogleApiSource {
    /// Identifier. Resource name of the form
    /// projects/{project}/locations/{location}/googleApiSources/{google_api_source}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server assigned unique identifier for the channel. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Output only. This checksum is computed by the server based on the value of
    /// other fields, and might be sent only on update and delete requests to
    /// ensure that the client has an up-to-date value before proceeding.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Resource labels.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource annotations.
    #[prost(map = "string, string", tag = "7")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource display name.
    #[prost(string, tag = "8")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Destination is the message bus that the GoogleApiSource is
    /// delivering to. It must be point to the full resource name of a MessageBus.
    /// Format:
    /// "projects/{PROJECT_ID}/locations/{region}/messagesBuses/{MESSAGE_BUS_ID)
    #[prost(string, tag = "9")]
    pub destination: ::prost::alloc::string::String,
    /// Optional. Resource name of a KMS crypto key (managed by the user) used to
    /// encrypt/decrypt their event data.
    ///
    /// It must match the pattern
    /// `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
    #[prost(string, tag = "10")]
    pub crypto_key_name: ::prost::alloc::string::String,
    /// Optional. Config to control Platform logging for the GoogleApiSource.
    #[prost(message, optional, tag = "11")]
    pub logging_config: ::core::option::Option<LoggingConfig>,
}
/// A GoogleChannelConfig is a resource that stores the custom settings
/// respected by Eventarc first-party triggers in the matching region.
/// Once configured, first-party event data will be protected
/// using the specified custom managed encryption key instead of Google-managed
/// encryption keys.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GoogleChannelConfig {
    /// Required. The resource name of the config. Must be in the format of,
    /// `projects/{project}/locations/{location}/googleChannelConfig`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "6")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Resource name of a KMS crypto key (managed by the user) used to
    /// encrypt/decrypt their event data.
    ///
    /// It must match the pattern
    /// `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
    #[prost(string, tag = "7")]
    pub crypto_key_name: ::prost::alloc::string::String,
}
/// MessageBus for the messages flowing through the system. The admin has
/// visibility and control over the messages being published and consumed and can
/// restrict publishers and subscribers to only a subset of data available in the
/// system by defining authorization policies.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MessageBus {
    /// Identifier. Resource name of the form
    /// projects/{project}/locations/{location}/messageBuses/{message_bus}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server assigned unique identifier for the channel. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Output only. This checksum is computed by the server based on the value of
    /// other fields, and might be sent only on update and delete requests to
    /// ensure that the client has an up-to-date value before proceeding.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Resource labels.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource annotations.
    #[prost(map = "string, string", tag = "7")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Resource display name.
    #[prost(string, tag = "8")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Resource name of a KMS crypto key (managed by the user) used to
    /// encrypt/decrypt their event data.
    ///
    /// It must match the pattern
    /// `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
    #[prost(string, tag = "10")]
    pub crypto_key_name: ::prost::alloc::string::String,
    /// Optional. Config to control Platform logging for the Message Bus. This log
    /// configuration is applied to the Message Bus itself, and all the Enrollments
    /// attached to it.
    #[prost(message, optional, tag = "11")]
    pub logging_config: ::core::option::Option<LoggingConfig>,
}
/// A representation of the Pipeline resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Pipeline {
    /// Identifier. The resource name of the Pipeline. Must be unique within the
    /// location of the project and must be in
    /// `projects/{project}/locations/{location}/pipelines/{pipeline}` format.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    /// A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
    /// to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
    /// "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    /// A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
    /// to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
    /// "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. User labels attached to the Pipeline that can be used to group
    /// resources. An object containing a list of "key": value pairs. Example: {
    /// "name": "wrench", "mass": "1.3kg", "count": "3" }.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. Server-assigned unique identifier for the Pipeline. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "5")]
    pub uid: ::prost::alloc::string::String,
    /// Optional. User-defined annotations. See
    /// <https://google.aip.dev/128#annotations.>
    #[prost(map = "string, string", tag = "6")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Display name of resource.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. List of destinations to which messages will be forwarded.
    /// Currently, exactly one destination is supported per Pipeline.
    #[prost(message, repeated, tag = "8")]
    pub destinations: ::prost::alloc::vec::Vec<pipeline::Destination>,
    /// Optional. List of mediation operations to be performed on the message.
    /// Currently, only one Transformation operation is allowed in each Pipeline.
    #[prost(message, repeated, tag = "9")]
    pub mediations: ::prost::alloc::vec::Vec<pipeline::Mediation>,
    /// Optional. Resource name of a KMS crypto key (managed by the user) used to
    /// encrypt/decrypt the event data. If not set, an internal Google-owned key
    /// will be used to encrypt messages. It must match the pattern
    /// "projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
    #[prost(string, tag = "10")]
    pub crypto_key_name: ::prost::alloc::string::String,
    /// Optional. The payload format expected for the messages received by the
    /// Pipeline. If input_payload_format is set then any messages not matching
    /// this format will be treated as persistent errors. If input_payload_format
    /// is not set, then the message data will be treated as an opaque binary and
    /// no output format can be set on the Pipeline through the
    /// Pipeline.Destination.output_payload_format field. Any Mediations on the
    /// Pipeline that involve access to the data field will fail as persistent
    /// errors.
    #[prost(message, optional, tag = "11")]
    pub input_payload_format: ::core::option::Option<pipeline::MessagePayloadFormat>,
    /// Optional. Config to control Platform Logging for Pipelines.
    #[prost(message, optional, tag = "12")]
    pub logging_config: ::core::option::Option<LoggingConfig>,
    /// Optional. The retry policy to use in the pipeline.
    #[prost(message, optional, tag = "13")]
    pub retry_policy: ::core::option::Option<pipeline::RetryPolicy>,
    /// Output only. This checksum is computed by the server based on the value of
    /// other fields, and might be sent only on create requests to ensure that the
    /// client has an up-to-date value before proceeding.
    #[prost(string, tag = "99")]
    pub etag: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Pipeline`.
pub mod pipeline {
    /// Represents the format of message data.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct MessagePayloadFormat {
        /// The kind of message format.
        /// One of Protobuf, Avro, and JSON supported.
        /// This allows specification of what specific format
        /// messages are sent and received.
        #[prost(oneof = "message_payload_format::Kind", tags = "1, 2, 3")]
        pub kind: ::core::option::Option<message_payload_format::Kind>,
    }
    /// Nested message and enum types in `MessagePayloadFormat`.
    pub mod message_payload_format {
        /// The format of a JSON message payload.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct JsonFormat {}
        /// The format of a Protobuf message payload.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct ProtobufFormat {
            /// Optional. The entire schema definition is stored in this field.
            #[prost(string, tag = "1")]
            pub schema_definition: ::prost::alloc::string::String,
        }
        /// The format of an AVRO message payload.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct AvroFormat {
            /// Optional. The entire schema definition is stored in this field.
            #[prost(string, tag = "1")]
            pub schema_definition: ::prost::alloc::string::String,
        }
        /// The kind of message format.
        /// One of Protobuf, Avro, and JSON supported.
        /// This allows specification of what specific format
        /// messages are sent and received.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Kind {
            /// Optional. Protobuf format.
            #[prost(message, tag = "1")]
            Protobuf(ProtobufFormat),
            /// Optional. Avro format.
            #[prost(message, tag = "2")]
            Avro(AvroFormat),
            /// Optional. JSON format.
            #[prost(message, tag = "3")]
            Json(JsonFormat),
        }
    }
    /// Represents a target of an invocation over HTTP.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Destination {
        /// Optional. Network config is used to configure how Pipeline resolves and
        /// connects to a destination.
        #[prost(message, optional, tag = "1")]
        pub network_config: ::core::option::Option<destination::NetworkConfig>,
        /// Optional. An authentication config used to authenticate message requests,
        /// such that destinations can verify the source. For example, this can be
        /// used with private GCP destinations that require GCP credentials to access
        /// like Cloud Run. This field is optional and should be set only by users
        /// interested in authenticated push
        #[prost(message, optional, tag = "5")]
        pub authentication_config: ::core::option::Option<
            destination::AuthenticationConfig,
        >,
        /// Optional. The message format before it is delivered to the destination.
        /// If not set, the message will be delivered in the format it was originally
        /// delivered to the Pipeline. This field can only be set if
        /// Pipeline.input_payload_format is also set.
        #[prost(message, optional, tag = "6")]
        pub output_payload_format: ::core::option::Option<MessagePayloadFormat>,
        /// The destination identifier to which the request should be routed to.
        #[prost(oneof = "destination::DestinationDescriptor", tags = "2, 3, 4, 8")]
        pub destination_descriptor: ::core::option::Option<
            destination::DestinationDescriptor,
        >,
    }
    /// Nested message and enum types in `Destination`.
    pub mod destination {
        /// Represents a network config to be used for destination resolution and
        /// connectivity.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct NetworkConfig {
            /// Required. Name of the NetworkAttachment that allows access to the
            /// consumer VPC. Format:
            /// `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
            #[prost(string, tag = "1")]
            pub network_attachment: ::prost::alloc::string::String,
        }
        /// Represents a HTTP endpoint destination.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct HttpEndpoint {
            /// Required. The URI of the HTTP enpdoint.
            ///
            /// The value must be a RFC2396 URI string.
            /// Examples: `<https://svc.us-central1.p.local:8080/route`.>
            /// Only the HTTPS protocol is supported.
            #[prost(string, tag = "1")]
            pub uri: ::prost::alloc::string::String,
            /// Optional. The CEL expression used to modify how the destination-bound
            /// HTTP request is constructed.
            ///
            /// If a binding expression is not specified here, the message
            /// is treated as a CloudEvent and is mapped to the HTTP request according
            /// to the CloudEvent HTTP Protocol Binding Binary Content Mode. In this
            /// representation, all fields except the `data` and `datacontenttype`
            /// field on the message are mapped to HTTP request headers with a prefix
            /// of `ce-`.
            ///
            /// To construct the HTTP request payload and the value of the content-type
            /// HTTP header, the payload format is defined as follows:
            ///
            /// 1. Use the output_payload_format_type on the Pipeline.Destination if it
            ///    is set, else:
            /// 1. Use the input_payload_format_type on the Pipeline if it is set,
            ///    else:
            /// 1. Treat the payload as opaque binary data.
            ///
            /// The `data` field of the message is converted to the payload format or
            /// left as-is for case 3) and then attached as the payload of the HTTP
            /// request. The `content-type` header on the HTTP request is set to the
            /// payload format type or left empty for case 3). However, if a mediation
            /// has updated the `datacontenttype` field on the message so that it is
            /// not the same as the payload format type but it is still a prefix of the
            /// payload format type, then the `content-type` header on the HTTP request
            /// is set to this `datacontenttype` value. For example, if the
            /// `datacontenttype` is "application/json" and the payload format type is
            /// "application/json; charset=utf-8", then the `content-type` header on
            /// the HTTP request is set to "application/json; charset=utf-8".
            ///
            /// If a non-empty binding expression is specified then this expression is
            /// used to modify the default CloudEvent HTTP Protocol Binding Binary
            /// Content representation.
            /// The result of the CEL expression must be a map of key/value pairs
            /// which is used as follows:
            ///
            /// * If a map named `headers` exists on the result of the expression,
            ///   then its key/value pairs are directly mapped to the HTTP request
            ///   headers. The headers values are constructed from the corresponding
            ///   value type’s canonical representation. If the `headers` field doesn’t
            ///   exist then the resulting HTTP request will be the headers of the
            ///   CloudEvent HTTP Binding Binary Content Mode representation of the final
            ///   message. Note: If the specified binding expression, has updated the
            ///   `datacontenttype` field on the message so that it is not the same as
            ///   the payload format type but it is still a prefix of the payload format
            ///   type, then the `content-type` header in the `headers` map is set to
            ///   this `datacontenttype` value.
            /// * If a field named `body` exists on the result of the expression then
            ///   its value is directly mapped to the body of the request. If the value
            ///   of the `body` field is of type bytes or string then it is used for
            ///   the HTTP request body as-is, with no conversion. If the body field is
            ///   of any other type then it is converted to a JSON string. If the body
            ///   field does not exist then the resulting payload of the HTTP request
            ///   will be data value of the CloudEvent HTTP Binding Binary Content Mode
            ///   representation of the final message as described earlier.
            /// * Any other fields in the resulting expression will be ignored.
            ///
            /// The CEL expression may access the incoming CloudEvent message in its
            /// definition, as follows:
            ///
            /// * The `data` field of the incoming CloudEvent message can be accessed
            ///   using the `message.data` value. Subfields of `message.data` may also be
            ///   accessed if an input_payload_format has been specified on the Pipeline.
            /// * Each attribute of the incoming CloudEvent message can be accessed
            ///   using the `message.<key>` value, where <key> is replaced with the
            ///   name of the attribute.
            /// * Existing headers can be accessed in the CEL expression using the
            ///   `headers` variable. The `headers` variable defines a map of key/value
            ///   pairs corresponding to the HTTP headers of the CloudEvent HTTP Binding
            ///   Binary Content Mode representation of the final message as described
            ///   earlier. For example, the following CEL expression can be used to
            ///   construct an HTTP request by adding an additional header to the HTTP
            ///   headers of the CloudEvent HTTP Binding Binary Content Mode
            ///   representation of the final message and by overwriting the body of the
            ///   request:
            ///
            /// ```text,
            /// {
            ///   "headers": headers.merge({"new-header-key": "new-header-value"}),
            ///   "body": "new-body"
            /// }
            /// ```
            ///
            /// Additionally, the following CEL extension functions are provided for
            /// use in this CEL expression:
            ///
            /// * toBase64Url:
            ///   map.toBase64Url() -> string
            ///   * Converts a CelValue to a base64url encoded string
            /// * toJsonString: map.toJsonString() -> string
            ///   * Converts a CelValue to a JSON string
            /// * merge:
            ///   map1.merge(map2) -> map3
            ///   * Merges the passed CEL map with the existing CEL map the
            ///     function is applied to.
            ///   * If the same key exists in both maps, if the key's value is type
            ///     map both maps are merged else the value from the passed map is
            ///     used.
            /// * denormalize:
            ///   map.denormalize() -> map
            ///   * Denormalizes a CEL map such that every value of type map or key
            ///     in the map is expanded to return a single level map.
            ///   * The resulting keys are "." separated indices of the map keys.
            ///   * For example:
            ///     {
            ///     "a": 1,
            ///     "b": {
            ///     "c": 2,
            ///     "d": 3
            ///     }
            ///     "e": \[4, 5\]
            ///     }
            ///     .denormalize()
            ///     -> {
            ///     "a": 1,
            ///     "b.c": 2,
            ///     "b.d": 3,
            ///     "e.0": 4,
            ///     "e.1": 5
            ///     }
            /// * setField:
            ///   map.setField(key, value) -> message
            ///   * Sets the field of the message with the given key to the
            ///     given value.
            ///   * If the field is not present it will be added.
            ///   * If the field is present it will be overwritten.
            ///   * The key can be a dot separated path to set a field in a nested
            ///     message.
            ///   * Key must be of type string.
            ///   * Value may be any valid type.
            /// * removeFields:
            ///   map.removeFields(\[key1, key2, ...\]) -> message
            ///   * Removes the fields of the map with the given keys.
            ///   * The keys can be a dot separated path to remove a field in a
            ///     nested message.
            ///   * If a key is not found it will be ignored.
            ///   * Keys must be of type string.
            /// * toMap:
            ///   \[map1, map2, ...\].toMap() -> map
            ///   * Converts a CEL list of CEL maps to a single CEL map
            /// * toDestinationPayloadFormat():
            ///   message.data.toDestinationPayloadFormat() -> string or bytes
            ///   * Converts the message data to the destination payload format
            ///     specified in Pipeline.Destination.output_payload_format
            ///   * This function is meant to be applied to the message.data field.
            ///   * If the destination payload format is not set, the function will
            ///     return the message data unchanged.
            /// * toCloudEventJsonWithPayloadFormat:
            ///   message.toCloudEventJsonWithPayloadFormat() -> map
            ///   * Converts a message to the corresponding structure of JSON
            ///     format for CloudEvents
            ///   * This function applies toDestinationPayloadFormat() to the
            ///     message data. It also sets the corresponding datacontenttype of
            ///     the CloudEvent, as indicated by
            ///     Pipeline.Destination.output_payload_format. If no
            ///     output_payload_format is set it will use the existing
            ///     datacontenttype on the CloudEvent if present, else leave
            ///     datacontenttype absent.
            ///   * This function expects that the content of the message will
            ///     adhere to the standard CloudEvent format. If it doesn’t then this
            ///     function will fail.
            ///   * The result is a CEL map that corresponds to the JSON
            ///     representation of the CloudEvent. To convert that data to a JSON
            ///     string it can be chained with the toJsonString function.
            ///
            /// The Pipeline expects that the message it receives adheres to the
            /// standard CloudEvent format. If it doesn’t then the outgoing message
            /// request may fail with a persistent error.
            #[prost(string, tag = "3")]
            pub message_binding_template: ::prost::alloc::string::String,
        }
        /// Represents a config used to authenticate message requests.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct AuthenticationConfig {
            /// The type of authentication method.
            #[prost(
                oneof = "authentication_config::AuthenticationMethodDescriptor",
                tags = "1, 2"
            )]
            pub authentication_method_descriptor: ::core::option::Option<
                authentication_config::AuthenticationMethodDescriptor,
            >,
        }
        /// Nested message and enum types in `AuthenticationConfig`.
        pub mod authentication_config {
            /// Represents a config used to authenticate with a Google OIDC token using
            /// a GCP service account. Use this authentication method to invoke your
            /// Cloud Run and Cloud Functions destinations or HTTP endpoints that
            /// support Google OIDC.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct OidcToken {
                /// Required. Service account email used to generate the OIDC Token.
                /// The principal who calls this API must have
                /// iam.serviceAccounts.actAs permission in the service account. See
                /// <https://cloud.google.com/iam/docs/understanding-service-accounts?hl=en#sa_common>
                /// for more information. Eventarc service agents must have
                /// roles/roles/iam.serviceAccountTokenCreator role to allow the
                /// Pipeline to create OpenID tokens for authenticated requests.
                #[prost(string, tag = "1")]
                pub service_account: ::prost::alloc::string::String,
                /// Optional. Audience to be used to generate the OIDC Token. The
                /// audience claim identifies the recipient that the JWT is intended for.
                /// If unspecified, the destination URI will be used.
                #[prost(string, tag = "2")]
                pub audience: ::prost::alloc::string::String,
            }
            /// Contains information needed for generating an
            /// [OAuth token](<https://developers.google.com/identity/protocols/OAuth2>).
            /// This type of authorization should generally only be used when calling
            /// Google APIs hosted on \*.googleapis.com.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct OAuthToken {
                /// Required. Service account email used to generate the [OAuth
                /// token](<https://developers.google.com/identity/protocols/OAuth2>).
                /// The principal who calls this API must have
                /// iam.serviceAccounts.actAs permission in the service account. See
                /// <https://cloud.google.com/iam/docs/understanding-service-accounts?hl=en#sa_common>
                /// for more information. Eventarc service agents must have
                /// roles/roles/iam.serviceAccountTokenCreator role to allow Pipeline
                /// to create OAuth2 tokens for authenticated requests.
                #[prost(string, tag = "1")]
                pub service_account: ::prost::alloc::string::String,
                /// Optional. OAuth scope to be used for generating OAuth access token.
                /// If not specified, "<https://www.googleapis.com/auth/cloud-platform">
                /// will be used.
                #[prost(string, tag = "2")]
                pub scope: ::prost::alloc::string::String,
            }
            /// The type of authentication method.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
            pub enum AuthenticationMethodDescriptor {
                /// Optional. This authenticate method will apply Google OIDC tokens
                /// signed by a GCP service account to the requests.
                #[prost(message, tag = "1")]
                GoogleOidc(OidcToken),
                /// Optional. If specified, an [OAuth
                /// token](<https://developers.google.com/identity/protocols/OAuth2>) will
                /// be generated and attached as an `Authorization` header in the HTTP
                /// request.
                ///
                /// This type of authorization should generally only be used when calling
                /// Google APIs hosted on \*.googleapis.com.
                #[prost(message, tag = "2")]
                OauthToken(OAuthToken),
            }
        }
        /// The destination identifier to which the request should be routed to.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum DestinationDescriptor {
            /// Optional. An HTTP endpoint destination described by an URI.
            /// If a DNS FQDN is provided as the endpoint, Pipeline will create a
            /// peering zone to the consumer VPC and forward DNS requests to the VPC
            /// specified by network config to resolve the service endpoint. See:
            /// <https://cloud.google.com/dns/docs/zones/zones-overview#peering_zones>
            #[prost(message, tag = "2")]
            HttpEndpoint(HttpEndpoint),
            /// Optional. The resource name of the Workflow whose Executions are
            /// triggered by the events. The Workflow resource should be deployed in
            /// the same project as the Pipeline. Format:
            /// `projects/{project}/locations/{location}/workflows/{workflow}`
            #[prost(string, tag = "3")]
            Workflow(::prost::alloc::string::String),
            /// Optional. The resource name of the Message Bus to which events should
            /// be published. The Message Bus resource should exist in the same project
            /// as the Pipeline. Format:
            /// `projects/{project}/locations/{location}/messageBuses/{message_bus}`
            #[prost(string, tag = "4")]
            MessageBus(::prost::alloc::string::String),
            /// Optional. The resource name of the Pub/Sub topic to which events should
            /// be published. Format:
            /// `projects/{project}/locations/{location}/topics/{topic}`
            #[prost(string, tag = "8")]
            Topic(::prost::alloc::string::String),
        }
    }
    /// Mediation defines different ways to modify the Pipeline.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Mediation {
        /// The config of mediation.
        #[prost(oneof = "mediation::MediationDescriptor", tags = "1")]
        pub mediation_descriptor: ::core::option::Option<mediation::MediationDescriptor>,
    }
    /// Nested message and enum types in `Mediation`.
    pub mod mediation {
        /// Transformation defines the way to transform an incoming message.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Transformation {
            /// Optional. The CEL expression template to apply to transform messages.
            /// The following CEL extension functions are provided for
            /// use in this CEL expression:
            ///
            /// * merge:
            ///   map1.merge(map2) -> map3
            ///   * Merges the passed CEL map with the existing CEL map the
            ///     function is applied to.
            ///   * If the same key exists in both maps, if the key's value is type
            ///     map both maps are merged else the value from the passed map is
            ///     used.
            /// * denormalize:
            ///   map.denormalize() -> map
            ///   * Denormalizes a CEL map such that every value of type map or key
            ///     in the map is expanded to return a single level map.
            ///   * The resulting keys are "." separated indices of the map keys.
            ///   * For example:
            ///     {
            ///     "a": 1,
            ///     "b": {
            ///     "c": 2,
            ///     "d": 3
            ///     }
            ///     "e": \[4, 5\]
            ///     }
            ///     .denormalize()
            ///     -> {
            ///     "a": 1,
            ///     "b.c": 2,
            ///     "b.d": 3,
            ///     "e.0": 4,
            ///     "e.1": 5
            ///     }
            /// * setField:
            ///   map.setField(key, value) -> message
            ///   * Sets the field of the message with the given key to the
            ///     given value.
            ///   * If the field is not present it will be added.
            ///   * If the field is present it will be overwritten.
            ///   * The key can be a dot separated path to set a field in a nested
            ///     message.
            ///   * Key must be of type string.
            ///   * Value may be any valid type.
            /// * removeFields:
            ///   map.removeFields(\[key1, key2, ...\]) -> message
            ///   * Removes the fields of the map with the given keys.
            ///   * The keys can be a dot separated path to remove a field in a
            ///     nested message.
            ///   * If a key is not found it will be ignored.
            ///   * Keys must be of type string.
            /// * toMap:
            ///   \[map1, map2, ...\].toMap() -> map
            ///   * Converts a CEL list of CEL maps to a single CEL map
            /// * toDestinationPayloadFormat():
            ///   message.data.toDestinationPayloadFormat() -> string or bytes
            ///   * Converts the message data to the destination payload format
            ///     specified in Pipeline.Destination.output_payload_format
            ///   * This function is meant to be applied to the message.data field.
            ///   * If the destination payload format is not set, the function will
            ///     return the message data unchanged.
            /// * toCloudEventJsonWithPayloadFormat:
            ///   message.toCloudEventJsonWithPayloadFormat() -> map
            ///   * Converts a message to the corresponding structure of JSON
            ///     format for CloudEvents
            ///   * This function applies toDestinationPayloadFormat() to the
            ///     message data. It also sets the corresponding datacontenttype of
            ///     the CloudEvent, as indicated by
            ///     Pipeline.Destination.output_payload_format. If no
            ///     output_payload_format is set it will use the existing
            ///     datacontenttype on the CloudEvent if present, else leave
            ///     datacontenttype absent.
            ///   * This function expects that the content of the message will
            ///     adhere to the standard CloudEvent format. If it doesn’t then this
            ///     function will fail.
            ///   * The result is a CEL map that corresponds to the JSON
            ///     representation of the CloudEvent. To convert that data to a JSON
            ///     string it can be chained with the toJsonString function.
            #[prost(string, tag = "1")]
            pub transformation_template: ::prost::alloc::string::String,
        }
        /// The config of mediation.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum MediationDescriptor {
            /// Optional. How the Pipeline is to transform messages
            #[prost(message, tag = "1")]
            Transformation(Transformation),
        }
    }
    /// The retry policy configuration for the Pipeline. The pipeline
    /// exponentially backs off in case the destination is non responsive or
    /// returns a retryable error code. The default semantics are as follows:
    /// The backoff starts with a 5 second delay and doubles the
    /// delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.).
    /// The delay is capped at 60 seconds by default.
    /// Please note that if you set the min_retry_delay and max_retry_delay fields
    /// to the same value this will make the duration between retries constant.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RetryPolicy {
        /// Optional. The maximum number of delivery attempts for any message. The
        /// value must be between 1 and 100. The default value for this field is 5.
        #[prost(int32, tag = "1")]
        pub max_attempts: i32,
        /// Optional. The minimum amount of seconds to wait between retry attempts.
        /// The value must be between 1 and 600. The default value for this field
        /// is 5.
        #[prost(message, optional, tag = "2")]
        pub min_retry_delay: ::core::option::Option<::prost_types::Duration>,
        /// Optional. The maximum amount of seconds to wait between retry attempts.
        /// The value must be between 1 and 600. The default value for this field
        /// is 60.
        #[prost(message, optional, tag = "3")]
        pub max_retry_delay: ::core::option::Option<::prost_types::Duration>,
    }
}
/// Network Configuration that can be inherited by other protos.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NetworkConfig {
    /// Required. Name of the NetworkAttachment that allows access to the
    /// customer's VPC. Format:
    /// `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
    #[prost(string, tag = "1")]
    pub network_attachment: ::prost::alloc::string::String,
}
/// A representation of the trigger resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Trigger {
    /// Required. The resource name of the trigger. Must be unique within the
    /// location of the project and must be in
    /// `projects/{project}/locations/{location}/triggers/{trigger}` format.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-assigned unique identifier for the trigger. The value
    /// is a UUID4 string and guaranteed to remain unchanged until the resource is
    /// deleted.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last-modified time.
    #[prost(message, optional, tag = "6")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Required. Unordered list. The list of filters that applies to event
    /// attributes. Only events that match all the provided filters are sent to the
    /// destination.
    #[prost(message, repeated, tag = "8")]
    pub event_filters: ::prost::alloc::vec::Vec<EventFilter>,
    /// Optional. The IAM service account email associated with the trigger. The
    /// service account represents the identity of the trigger.
    ///
    /// The `iam.serviceAccounts.actAs` permission must be granted on the service
    /// account to allow a principal to impersonate the service account. For more
    /// information, see the
    /// [Roles and permissions](/eventarc/docs/all-roles-permissions) page specific
    /// to the trigger destination.
    #[prost(string, tag = "9")]
    pub service_account: ::prost::alloc::string::String,
    /// Required. Destination specifies where the events should be sent to.
    #[prost(message, optional, tag = "10")]
    pub destination: ::core::option::Option<Destination>,
    /// Optional. To deliver messages, Eventarc might use other Google Cloud
    /// products as a transport intermediary. This field contains a reference to
    /// that transport intermediary. This information can be used for debugging
    /// purposes.
    #[prost(message, optional, tag = "11")]
    pub transport: ::core::option::Option<Transport>,
    /// Optional. User labels attached to the triggers that can be used to group
    /// resources.
    #[prost(map = "string, string", tag = "12")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. The name of the channel associated with the trigger in
    /// `projects/{project}/locations/{location}/channels/{channel}` format.
    /// You must provide a channel to receive events from Eventarc SaaS partners.
    #[prost(string, tag = "13")]
    pub channel: ::prost::alloc::string::String,
    /// Output only. The reason(s) why a trigger is in FAILED state.
    #[prost(map = "string, message", tag = "15")]
    pub conditions: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        StateCondition,
    >,
    /// Optional. EventDataContentType specifies the type of payload in MIME
    /// format that is expected from the CloudEvent data field. This is set to
    /// `application/json` if the value is not defined.
    #[prost(string, tag = "16")]
    pub event_data_content_type: ::prost::alloc::string::String,
    /// Output only. Whether or not this Trigger satisfies the requirements of
    /// physical zone separation
    #[prost(bool, tag = "19")]
    pub satisfies_pzs: bool,
    /// Output only. This checksum is computed by the server based on the value of
    /// other fields, and might be sent only on create requests to ensure that the
    /// client has an up-to-date value before proceeding.
    #[prost(string, tag = "99")]
    pub etag: ::prost::alloc::string::String,
}
/// Filters events based on exact matches on the CloudEvents attributes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EventFilter {
    /// Required. The name of a CloudEvents attribute. Currently, only a subset of
    /// attributes are supported for filtering. You can [retrieve a specific
    /// provider's supported event
    /// types](/eventarc/docs/list-providers#describe-provider).
    ///
    /// All triggers MUST provide a filter for the 'type' attribute.
    #[prost(string, tag = "1")]
    pub attribute: ::prost::alloc::string::String,
    /// Required. The value for the attribute.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
    /// Optional. The operator used for matching the events with the value of the
    /// filter. If not specified, only events that have an exact key-value pair
    /// specified in the filter are matched. The allowed values are `path_pattern`
    /// and `match-path-pattern`. `path_pattern` is only allowed for GCFv1
    /// triggers.
    #[prost(string, tag = "3")]
    pub operator: ::prost::alloc::string::String,
}
/// A condition that is part of the trigger state computation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StateCondition {
    /// The canonical code of the condition.
    #[prost(enumeration = "super::super::super::rpc::Code", tag = "1")]
    pub code: i32,
    /// Human-readable message.
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
/// Represents a target of an invocation over HTTP.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Destination {
    /// Optional. Network config is used to configure how Eventarc resolves and
    /// connect to a destination.
    /// This should only be used with HttpEndpoint destination type.
    #[prost(message, optional, tag = "6")]
    pub network_config: ::core::option::Option<NetworkConfig>,
    #[prost(oneof = "destination::Descriptor", tags = "1, 2, 3, 4, 5")]
    pub descriptor: ::core::option::Option<destination::Descriptor>,
}
/// Nested message and enum types in `Destination`.
pub mod destination {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Descriptor {
        /// Cloud Run fully-managed resource that receives the events. The resource
        /// should be in the same project as the trigger.
        #[prost(message, tag = "1")]
        CloudRun(super::CloudRun),
        /// The Cloud Function resource name. Cloud Functions V1 and V2 are
        /// supported.
        /// Format: `projects/{project}/locations/{location}/functions/{function}`
        ///
        /// This is a read-only field. Creating Cloud Functions V1/V2 triggers is
        /// only supported via the Cloud Functions product. An error will be returned
        /// if the user sets this value.
        #[prost(string, tag = "2")]
        CloudFunction(::prost::alloc::string::String),
        /// A GKE service capable of receiving events. The service should be running
        /// in the same project as the trigger.
        #[prost(message, tag = "3")]
        Gke(super::Gke),
        /// The resource name of the Workflow whose Executions are triggered by
        /// the events. The Workflow resource should be deployed in the same project
        /// as the trigger.
        /// Format: `projects/{project}/locations/{location}/workflows/{workflow}`
        #[prost(string, tag = "4")]
        Workflow(::prost::alloc::string::String),
        /// An HTTP endpoint destination described by an URI.
        #[prost(message, tag = "5")]
        HttpEndpoint(super::HttpEndpoint),
    }
}
/// Represents the transport intermediaries created for the trigger to
/// deliver events.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Transport {
    #[prost(oneof = "transport::Intermediary", tags = "1")]
    pub intermediary: ::core::option::Option<transport::Intermediary>,
}
/// Nested message and enum types in `Transport`.
pub mod transport {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Intermediary {
        /// The Pub/Sub topic and subscription used by Eventarc as a transport
        /// intermediary.
        #[prost(message, tag = "1")]
        Pubsub(super::Pubsub),
    }
}
/// Represents a Cloud Run destination.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudRun {
    /// Required. The name of the Cloud Run service being addressed. See
    /// <https://cloud.google.com/run/docs/reference/rest/v1/namespaces.services.>
    ///
    /// Only services located in the same project as the trigger object
    /// can be addressed.
    #[prost(string, tag = "1")]
    pub service: ::prost::alloc::string::String,
    /// Optional. The relative path on the Cloud Run service the events should be
    /// sent to.
    ///
    /// The value must conform to the definition of a URI path segment (section 3.3
    /// of RFC2396). Examples: "/route", "route", "route/subroute".
    #[prost(string, tag = "2")]
    pub path: ::prost::alloc::string::String,
    /// Required. The region the Cloud Run service is deployed in.
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
}
/// Represents a GKE destination.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Gke {
    /// Required. The name of the cluster the GKE service is running in. The
    /// cluster must be running in the same project as the trigger being created.
    #[prost(string, tag = "1")]
    pub cluster: ::prost::alloc::string::String,
    /// Required. The name of the Google Compute Engine in which the cluster
    /// resides, which can either be compute zone (for example, us-central1-a) for
    /// the zonal clusters or region (for example, us-central1) for regional
    /// clusters.
    #[prost(string, tag = "2")]
    pub location: ::prost::alloc::string::String,
    /// Required. The namespace the GKE service is running in.
    #[prost(string, tag = "3")]
    pub namespace: ::prost::alloc::string::String,
    /// Required. Name of the GKE service.
    #[prost(string, tag = "4")]
    pub service: ::prost::alloc::string::String,
    /// Optional. The relative path on the GKE service the events should be sent
    /// to.
    ///
    /// The value must conform to the definition of a URI path segment (section 3.3
    /// of RFC2396). Examples: "/route", "route", "route/subroute".
    #[prost(string, tag = "5")]
    pub path: ::prost::alloc::string::String,
}
/// Represents a Pub/Sub transport.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Pubsub {
    /// Optional. The name of the Pub/Sub topic created and managed by Eventarc as
    /// a transport for the event delivery. Format:
    /// `projects/{PROJECT_ID}/topics/{TOPIC_NAME}`.
    ///
    /// You can set an existing topic for triggers of the type
    /// `google.cloud.pubsub.topic.v1.messagePublished`. The topic you provide
    /// here is not deleted by Eventarc at trigger deletion.
    #[prost(string, tag = "1")]
    pub topic: ::prost::alloc::string::String,
    /// Output only. The name of the Pub/Sub subscription created and managed by
    /// Eventarc as a transport for the event delivery. Format:
    /// `projects/{PROJECT_ID}/subscriptions/{SUBSCRIPTION_NAME}`.
    #[prost(string, tag = "2")]
    pub subscription: ::prost::alloc::string::String,
}
/// Represents a HTTP endpoint destination.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct HttpEndpoint {
    /// Required. The URI of the HTTP enpdoint.
    ///
    /// The value must be a RFC2396 URI string.
    /// Examples: `<http://10.10.10.8:80/route`,>
    /// `<http://svc.us-central1.p.local:8080/`.>
    /// Only HTTP and HTTPS protocols are supported. The host can be either a
    /// static IP addressable from the VPC specified by the network config, or
    /// an internal DNS hostname of the service resolvable via Cloud DNS.
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
}
/// The request message for the GetTrigger method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTriggerRequest {
    /// Required. The name of the trigger to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListTriggers method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListTriggersRequest {
    /// Required. The parent collection to list triggers on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of triggers to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The page token; provide the value from the `next_page_token` field in a
    /// previous `ListTriggers` call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListTriggers` must match
    /// the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, trigger_id`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter field. Used to filter the Triggers to be listed. Possible filters
    /// are described in <https://google.aip.dev/160.> For example, using
    /// "?filter=destination:gke" would list only Triggers with a gke destination.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the `ListTriggers` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTriggersResponse {
    /// The requested triggers, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub triggers: ::prost::alloc::vec::Vec<Trigger>,
    /// A page token that can be sent to `ListTriggers` to request the next page.
    /// If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateTrigger method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateTriggerRequest {
    /// Required. The parent collection in which to add this trigger.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The trigger to create.
    #[prost(message, optional, tag = "2")]
    pub trigger: ::core::option::Option<Trigger>,
    /// Required. The user-provided ID to be assigned to the trigger.
    #[prost(string, tag = "3")]
    pub trigger_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdateTrigger method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateTriggerRequest {
    /// The trigger to be updated.
    #[prost(message, optional, tag = "1")]
    pub trigger: ::core::option::Option<Trigger>,
    /// The fields to be updated; only fields explicitly provided are updated.
    /// If no field mask is provided, all provided fields in the request are
    /// updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// If set to true, and the trigger is not found, a new trigger will be
    /// created. In this situation, `update_mask` is ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the DeleteTrigger method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteTriggerRequest {
    /// Required. The name of the trigger to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// If provided, the trigger will only be deleted if the etag matches the
    /// current etag on the resource.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// If set to true, and the trigger is not found, the request will succeed
    /// but no action will be taken on the server.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the GetChannel method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetChannelRequest {
    /// Required. The name of the channel to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListChannels method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListChannelsRequest {
    /// Required. The parent collection to list channels on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of channels to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The page token; provide the value from the `next_page_token` field in a
    /// previous `ListChannels` call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListChannels` must
    /// match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, channel_id`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
}
/// The response message for the `ListChannels` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChannelsResponse {
    /// The requested channels, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub channels: ::prost::alloc::vec::Vec<Channel>,
    /// A page token that can be sent to `ListChannels` to request the next page.
    /// If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateChannel method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateChannelRequest {
    /// Required. The parent collection in which to add this channel.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The channel to create.
    #[prost(message, optional, tag = "2")]
    pub channel: ::core::option::Option<Channel>,
    /// Required. The user-provided ID to be assigned to the channel.
    #[prost(string, tag = "3")]
    pub channel_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdateChannel method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateChannelRequest {
    /// The channel to be updated.
    #[prost(message, optional, tag = "1")]
    pub channel: ::core::option::Option<Channel>,
    /// The fields to be updated; only fields explicitly provided are updated.
    /// If no field mask is provided, all provided fields in the request are
    /// updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "3")]
    pub validate_only: bool,
}
/// The request message for the DeleteChannel method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteChannelRequest {
    /// Required. The name of the channel to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "2")]
    pub validate_only: bool,
}
/// The request message for the GetProvider method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProviderRequest {
    /// Required. The name of the provider to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListProviders method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProvidersRequest {
    /// Required. The parent of the provider to get.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of providers to return on each page.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The page token; provide the value from the `next_page_token` field in a
    /// previous `ListProviders` call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListProviders` must
    /// match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting oder is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, _id`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// The filter field that the list request will filter on.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the `ListProviders` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProvidersResponse {
    /// The requested providers, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub providers: ::prost::alloc::vec::Vec<Provider>,
    /// A page token that can be sent to `ListProviders` to request the next page.
    /// If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the GetChannelConnection method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetChannelConnectionRequest {
    /// Required. The name of the channel connection to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListChannelConnections method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListChannelConnectionsRequest {
    /// Required. The parent collection from which to list channel connections.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of channel connections to return on each page.
    ///
    /// Note: The service may send fewer responses.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The page token; provide the value from the `next_page_token` field in a
    /// previous `ListChannelConnections` call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListChannelConnetions`
    /// match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for the `ListChannelConnections` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChannelConnectionsResponse {
    /// The requested channel connections, up to the number specified in
    /// `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub channel_connections: ::prost::alloc::vec::Vec<ChannelConnection>,
    /// A page token that can be sent to `ListChannelConnections` to request the
    /// next page.
    /// If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateChannelConnection method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateChannelConnectionRequest {
    /// Required. The parent collection in which to add this channel connection.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Channel connection to create.
    #[prost(message, optional, tag = "2")]
    pub channel_connection: ::core::option::Option<ChannelConnection>,
    /// Required. The user-provided ID to be assigned to the channel connection.
    #[prost(string, tag = "3")]
    pub channel_connection_id: ::prost::alloc::string::String,
}
/// The request message for the DeleteChannelConnection method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteChannelConnectionRequest {
    /// Required. The name of the channel connection to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the UpdateGoogleChannelConfig method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateGoogleChannelConfigRequest {
    /// Required. The config to be updated.
    #[prost(message, optional, tag = "1")]
    pub google_channel_config: ::core::option::Option<GoogleChannelConfig>,
    /// The fields to be updated; only fields explicitly provided are updated.
    /// If no field mask is provided, all provided fields in the request are
    /// updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for the GetGoogleChannelConfig method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetGoogleChannelConfigRequest {
    /// Required. The name of the config to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the GetMessageBus method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetMessageBusRequest {
    /// Required. The name of the message bus to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListMessageBuses method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListMessageBusesRequest {
    /// Required. The parent collection to list triggers on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The page token; provide the value from the `next_page_token`
    /// field in a previous call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided must match
    /// the previous call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, update_time`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Optional. The filter field that the list request will filter on.
    /// Possible filtersare described in <https://google.aip.dev/160.>
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the `ListMessageBuses` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListMessageBusesResponse {
    /// The requested message buses, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub message_buses: ::prost::alloc::vec::Vec<MessageBus>,
    /// A page token that can be sent to `ListMessageBuses` to request the next
    /// page. If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the `ListMessageBusEnrollments` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListMessageBusEnrollmentsRequest {
    /// Required. The parent message bus to list enrollments on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The page token; provide the value from the `next_page_token`
    /// field in a previous call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided must match
    /// the previous call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for the `ListMessageBusEnrollments` method.\`
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListMessageBusEnrollmentsResponse {
    /// The requested enrollments, up to the number specified in `page_size`.
    #[prost(string, repeated, tag = "1")]
    pub enrollments: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A page token that can be sent to `ListMessageBusEnrollments` to request the
    /// next page. If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateMessageBus method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateMessageBusRequest {
    /// Required. The parent collection in which to add this message bus.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The message bus to create.
    #[prost(message, optional, tag = "2")]
    pub message_bus: ::core::option::Option<MessageBus>,
    /// Required. The user-provided ID to be assigned to the MessageBus. It should
    /// match the format (^[a-z](\[a-z0-9-\]{0,61}\[a-z0-9\])?$)
    #[prost(string, tag = "3")]
    pub message_bus_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdateMessageBus method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateMessageBusRequest {
    /// Required. The MessageBus to be updated.
    #[prost(message, optional, tag = "1")]
    pub message_bus: ::core::option::Option<MessageBus>,
    /// Optional. The fields to be updated; only fields explicitly provided are
    /// updated. If no field mask is provided, all provided fields in the request
    /// are updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. If set to true, and the MessageBus is not found, a new MessageBus
    /// will be created. In this situation, `update_mask` is ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the DeleteMessageBus method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteMessageBusRequest {
    /// Required. The name of the MessageBus to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If provided, the MessageBus will only be deleted if the etag
    /// matches the current etag on the resource.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set to true, and the MessageBus is not found, the request will
    /// succeed but no action will be taken on the server.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the GetEnrollment method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEnrollmentRequest {
    /// Required. The name of the Enrollment to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListEnrollments method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEnrollmentsRequest {
    /// Required. The parent collection to list triggers on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The page token; provide the value from the `next_page_token`
    /// field in a previous call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided must match
    /// the previous call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, update_time`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Optional. The filter field that the list request will filter on.
    /// Possible filtersare described in <https://google.aip.dev/160.>
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the `ListEnrollments` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEnrollmentsResponse {
    /// The requested Enrollments, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub enrollments: ::prost::alloc::vec::Vec<Enrollment>,
    /// A page token that can be sent to `ListEnrollments` to request the next
    /// page. If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateEnrollment method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEnrollmentRequest {
    /// Required. The parent collection in which to add this enrollment.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The enrollment to create.
    #[prost(message, optional, tag = "2")]
    pub enrollment: ::core::option::Option<Enrollment>,
    /// Required. The user-provided ID to be assigned to the Enrollment. It should
    /// match the format (^[a-z](\[a-z0-9-\]{0,61}\[a-z0-9\])?$).
    #[prost(string, tag = "3")]
    pub enrollment_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdateEnrollment method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEnrollmentRequest {
    /// Required. The Enrollment to be updated.
    #[prost(message, optional, tag = "1")]
    pub enrollment: ::core::option::Option<Enrollment>,
    /// Optional. The fields to be updated; only fields explicitly provided are
    /// updated. If no field mask is provided, all provided fields in the request
    /// are updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. If set to true, and the Enrollment is not found, a new Enrollment
    /// will be created. In this situation, `update_mask` is ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the DeleteEnrollment method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEnrollmentRequest {
    /// Required. The name of the Enrollment to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If provided, the Enrollment will only be deleted if the etag
    /// matches the current etag on the resource.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set to true, and the Enrollment is not found, the request will
    /// succeed but no action will be taken on the server.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the GetPipeline method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPipelineRequest {
    /// Required. The name of the pipeline to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListPipelines method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPipelinesRequest {
    /// Required. The parent collection to list pipelines on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The page token; provide the value from the `next_page_token`
    /// field in a previous call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided must match
    /// the previous call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, update_time`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Optional. The filter field that the list request will filter on.
    /// Possible filters are described in <https://google.aip.dev/160.>
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the ListPipelines method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPipelinesResponse {
    /// The requested pipelines, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub pipelines: ::prost::alloc::vec::Vec<Pipeline>,
    /// A page token that can be sent to `ListPipelines` to request the next
    /// page. If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreatePipeline method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePipelineRequest {
    /// Required. The parent collection in which to add this pipeline.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The pipeline to create.
    #[prost(message, optional, tag = "2")]
    pub pipeline: ::core::option::Option<Pipeline>,
    /// Required. The user-provided ID to be assigned to the Pipeline.
    #[prost(string, tag = "3")]
    pub pipeline_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdatePipeline method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePipelineRequest {
    /// Required. The Pipeline to be updated.
    #[prost(message, optional, tag = "1")]
    pub pipeline: ::core::option::Option<Pipeline>,
    /// Optional. The fields to be updated; only fields explicitly provided are
    /// updated. If no field mask is provided, all provided fields in the request
    /// are updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. If set to true, and the Pipeline is not found, a new Pipeline
    /// will be created. In this situation, `update_mask` is ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the DeletePipeline method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePipelineRequest {
    /// Required. The name of the Pipeline to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If provided, the Pipeline will only be deleted if the etag
    /// matches the current etag on the resource.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set to true, and the Pipeline is not found, the request will
    /// succeed but no action will be taken on the server.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the GetGoogleApiSource method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetGoogleApiSourceRequest {
    /// Required. The name of the google api source to get.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for the ListGoogleApiSources method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListGoogleApiSourcesRequest {
    /// Required. The parent collection to list GoogleApiSources on.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of results to return on each page.
    ///
    /// Note: The service may send fewer.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The page token; provide the value from the `next_page_token`
    /// field in a previous call to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided must match
    /// the previous call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. The sorting order of the resources returned. Value should be a
    /// comma-separated list of fields. The default sorting order is ascending. To
    /// specify descending order for a field, append a `desc` suffix; for example:
    /// `name desc, update_time`.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Optional. The filter field that the list request will filter on.
    /// Possible filtersare described in <https://google.aip.dev/160.>
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for the `ListGoogleApiSources` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGoogleApiSourcesResponse {
    /// The requested GoogleApiSources, up to the number specified in `page_size`.
    #[prost(message, repeated, tag = "1")]
    pub google_api_sources: ::prost::alloc::vec::Vec<GoogleApiSource>,
    /// A page token that can be sent to `ListMessageBusEnrollments` to request the
    /// next page. If this is empty, then there are no more pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unreachable resources, if any.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for the CreateGoogleApiSource method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGoogleApiSourceRequest {
    /// Required. The parent collection in which to add this google api source.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The google api source to create.
    #[prost(message, optional, tag = "2")]
    pub google_api_source: ::core::option::Option<GoogleApiSource>,
    /// Required. The user-provided ID to be assigned to the GoogleApiSource. It
    /// should match the format (^[a-z](\[a-z0-9-\]{0,61}\[a-z0-9\])?$).
    #[prost(string, tag = "3")]
    pub google_api_source_id: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the UpdateGoogleApiSource method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGoogleApiSourceRequest {
    /// Required. The GoogleApiSource to be updated.
    #[prost(message, optional, tag = "1")]
    pub google_api_source: ::core::option::Option<GoogleApiSource>,
    /// Optional. The fields to be updated; only fields explicitly provided are
    /// updated. If no field mask is provided, all provided fields in the request
    /// are updated. To update all fields, provide a field mask of "\*".
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. If set to true, and the GoogleApiSource is not found, a new
    /// GoogleApiSource will be created. In this situation, `update_mask` is
    /// ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// The request message for the DeleteGoogleApiSource method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteGoogleApiSourceRequest {
    /// Required. The name of the GoogleApiSource to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If provided, the MessageBus will only be deleted if the etag
    /// matches the current etag on the resource.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set to true, and the MessageBus is not found, the request will
    /// succeed but no action will be taken on the server.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
    /// Optional. If set, validate the request and preview the review, but do not
    /// post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Server-defined resource path for the target of the operation.
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "5")]
    pub status_message: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have successfully been cancelled
    /// have \[Operation.error\]\[\] value with a
    /// \[google.rpc.Status.code\]\[google.rpc.Status.code\] of 1, corresponding to
    /// `Code.CANCELLED`.
    #[prost(bool, tag = "6")]
    pub requested_cancellation: bool,
    /// Output only. API version used to start the operation.
    #[prost(string, tag = "7")]
    pub api_version: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod eventarc_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Eventarc allows users to subscribe to various events that are provided by
    /// Google Cloud services and forward them to supported destinations.
    #[derive(Debug, Clone)]
    pub struct EventarcClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EventarcClient<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> EventarcClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> EventarcClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            EventarcClient::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
        }
        /// Get a single trigger.
        pub async fn get_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTriggerRequest>,
        ) -> std::result::Result<tonic::Response<super::Trigger>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetTrigger",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetTrigger"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List triggers.
        pub async fn list_triggers(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTriggersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTriggersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListTriggers",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "ListTriggers"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new trigger in a particular project and location.
        pub async fn create_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateTriggerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateTrigger",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "CreateTrigger"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single trigger.
        pub async fn update_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateTriggerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateTrigger",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "UpdateTrigger"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single trigger.
        pub async fn delete_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTriggerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteTrigger",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "DeleteTrigger"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single Channel.
        pub async fn get_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChannelRequest>,
        ) -> std::result::Result<tonic::Response<super::Channel>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetChannel"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List channels.
        pub async fn list_channels(
            &mut self,
            request: impl tonic::IntoRequest<super::ListChannelsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListChannelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListChannels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "ListChannels"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new channel in a particular project and location.
        pub async fn create_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "CreateChannel"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single channel.
        pub async fn update_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "UpdateChannel"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single channel.
        pub async fn delete_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "DeleteChannel"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single Provider.
        pub async fn get_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Provider>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetProvider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetProvider"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List providers.
        pub async fn list_providers(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProvidersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProvidersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListProviders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "ListProviders"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single ChannelConnection.
        pub async fn get_channel_connection(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChannelConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ChannelConnection>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetChannelConnection",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "GetChannelConnection",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List channel connections.
        pub async fn list_channel_connections(
            &mut self,
            request: impl tonic::IntoRequest<super::ListChannelConnectionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListChannelConnectionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListChannelConnections",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "ListChannelConnections",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new ChannelConnection in a particular project and location.
        pub async fn create_channel_connection(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateChannelConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateChannelConnection",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "CreateChannelConnection",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single ChannelConnection.
        pub async fn delete_channel_connection(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteChannelConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteChannelConnection",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "DeleteChannelConnection",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a GoogleChannelConfig
        pub async fn get_google_channel_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGoogleChannelConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GoogleChannelConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetGoogleChannelConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "GetGoogleChannelConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single GoogleChannelConfig
        pub async fn update_google_channel_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGoogleChannelConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GoogleChannelConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateGoogleChannelConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "UpdateGoogleChannelConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single MessageBus.
        pub async fn get_message_bus(
            &mut self,
            request: impl tonic::IntoRequest<super::GetMessageBusRequest>,
        ) -> std::result::Result<tonic::Response<super::MessageBus>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetMessageBus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetMessageBus"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List message buses.
        pub async fn list_message_buses(
            &mut self,
            request: impl tonic::IntoRequest<super::ListMessageBusesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListMessageBusesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListMessageBuses",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "ListMessageBuses",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List message bus enrollments.
        pub async fn list_message_bus_enrollments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListMessageBusEnrollmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListMessageBusEnrollmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListMessageBusEnrollments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "ListMessageBusEnrollments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new MessageBus in a particular project and location.
        pub async fn create_message_bus(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateMessageBusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateMessageBus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "CreateMessageBus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single message bus.
        pub async fn update_message_bus(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateMessageBusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateMessageBus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "UpdateMessageBus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single message bus.
        pub async fn delete_message_bus(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteMessageBusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteMessageBus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "DeleteMessageBus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single Enrollment.
        pub async fn get_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEnrollmentRequest>,
        ) -> std::result::Result<tonic::Response<super::Enrollment>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetEnrollment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetEnrollment"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List Enrollments.
        pub async fn list_enrollments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEnrollmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEnrollmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListEnrollments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "ListEnrollments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new Enrollment in a particular project and location.
        pub async fn create_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEnrollmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateEnrollment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "CreateEnrollment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single Enrollment.
        pub async fn update_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEnrollmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateEnrollment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "UpdateEnrollment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single Enrollment.
        pub async fn delete_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEnrollmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteEnrollment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "DeleteEnrollment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single Pipeline.
        pub async fn get_pipeline(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPipelineRequest>,
        ) -> std::result::Result<tonic::Response<super::Pipeline>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetPipeline",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "GetPipeline"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List pipelines.
        pub async fn list_pipelines(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPipelinesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPipelinesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListPipelines",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.eventarc.v1.Eventarc", "ListPipelines"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new Pipeline in a particular project and location.
        pub async fn create_pipeline(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePipelineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreatePipeline",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "CreatePipeline",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single pipeline.
        pub async fn update_pipeline(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePipelineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdatePipeline",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "UpdatePipeline",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single pipeline.
        pub async fn delete_pipeline(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePipelineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeletePipeline",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "DeletePipeline",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get a single GoogleApiSource.
        pub async fn get_google_api_source(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGoogleApiSourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GoogleApiSource>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/GetGoogleApiSource",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "GetGoogleApiSource",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List GoogleApiSources.
        pub async fn list_google_api_sources(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGoogleApiSourcesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGoogleApiSourcesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/ListGoogleApiSources",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "ListGoogleApiSources",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new GoogleApiSource in a particular project and location.
        pub async fn create_google_api_source(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGoogleApiSourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/CreateGoogleApiSource",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "CreateGoogleApiSource",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update a single GoogleApiSource.
        pub async fn update_google_api_source(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGoogleApiSourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/UpdateGoogleApiSource",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "UpdateGoogleApiSource",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a single GoogleApiSource.
        pub async fn delete_google_api_source(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGoogleApiSourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.eventarc.v1.Eventarc/DeleteGoogleApiSource",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.eventarc.v1.Eventarc",
                        "DeleteGoogleApiSource",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
