pact_plugin_driver/

proto_v2.rs

// Build with PACT_PLUGIN_BUILD_PROTOBUFS set, then include the following
// tonic::include_proto!("io.pact.plugin.v2");

// ------------------ Generated --------------------------//

// This file is @generated by prost-build.
/// Request to verify the plugin has loaded OK
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InitPluginRequest {
    /// Implementation calling the plugin
    #[prost(string, tag = "1")]
    pub implementation: ::prost::alloc::string::String,
    /// Version of the implementation
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    /// Host capabilities provided by the driver and available to the plugin
    #[prost(string, repeated, tag = "3")]
    pub host_capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// UUID assigned by the driver at process start; the plugin includes this in every log record it emits
    #[prost(string, tag = "4")]
    pub plugin_instance_id: ::prost::alloc::string::String,
}
/// Entry to be added to the core catalogue. Each entry describes one of the features the plugin provides.
/// Entries will be stored in the catalogue under the key "plugin/$name/$type/$key".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CatalogueEntry {
    /// Entry type
    #[prost(enumeration = "catalogue_entry::EntryType", tag = "1")]
    pub r#type: i32,
    /// Entry key
    #[prost(string, tag = "2")]
    pub key: ::prost::alloc::string::String,
    /// Associated data required for the entry. For CONTENT_MATCHER and CONTENT_GENERATOR types, a "content-types"
    /// value (separated by semi-colons) is required for all the content types the plugin supports.
    #[prost(map = "string, string", tag = "3")]
    pub values: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `CatalogueEntry`.
pub mod catalogue_entry {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EntryType {
        /// Matcher for contents of messages, requests or response bodies
        ContentMatcher = 0,
        /// Generator for contents of messages, requests or response bodies
        ContentGenerator = 1,
        /// Transport for a network protocol
        Transport = 2,
        /// Matching rule for content field/values
        Matcher = 3,
        /// Type of interaction
        Interaction = 4,
        /// Generator for a content field/value. See proposal 006 (Field-level matchers and generators).
        Generator = 5,
    }
    impl EntryType {
        /// 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::ContentMatcher => "CONTENT_MATCHER",
                Self::ContentGenerator => "CONTENT_GENERATOR",
                Self::Transport => "TRANSPORT",
                Self::Matcher => "MATCHER",
                Self::Interaction => "INTERACTION",
                Self::Generator => "GENERATOR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONTENT_MATCHER" => Some(Self::ContentMatcher),
                "CONTENT_GENERATOR" => Some(Self::ContentGenerator),
                "TRANSPORT" => Some(Self::Transport),
                "MATCHER" => Some(Self::Matcher),
                "INTERACTION" => Some(Self::Interaction),
                "GENERATOR" => Some(Self::Generator),
                _ => None,
            }
        }
    }
}
/// Successful result of initialising the plugin
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitPluginSuccess {
    /// List of entries the plugin supports
    #[prost(message, repeated, tag = "1")]
    pub catalogue: ::prost::alloc::vec::Vec<CatalogueEntry>,
    /// Optional capabilities negotiated for this plugin instance
    #[prost(string, repeated, tag = "2")]
    pub plugin_capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Failure result of initialising the plugin
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InitPluginFailure {
    /// Error explaining why initialisation failed
    #[prost(string, tag = "1")]
    pub error: ::prost::alloc::string::String,
    /// Host capabilities the plugin requires but were not provided by the driver
    #[prost(string, repeated, tag = "2")]
    pub missing_host_capabilities: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
}
/// Response to init plugin, providing either the negotiated success response or a structured failure
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitPluginResponse {
    #[prost(oneof = "init_plugin_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<init_plugin_response::Response>,
}
/// Nested message and enum types in `InitPluginResponse`.
pub mod init_plugin_response {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        #[prost(message, tag = "1")]
        Success(super::InitPluginSuccess),
        #[prost(message, tag = "2")]
        Failure(super::InitPluginFailure),
    }
}
/// Catalogue of Core Pact + Plugin features
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Catalogue {
    /// List of entries from the core catalogue
    #[prost(message, repeated, tag = "1")]
    pub catalogue: ::prost::alloc::vec::Vec<CatalogueEntry>,
}
/// Message representing a request, response or message body
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Body {
    /// The content type of the body in MIME format (i.e. application/json)
    #[prost(string, tag = "1")]
    pub content_type: ::prost::alloc::string::String,
    /// Bytes of the actual content
    #[prost(message, optional, tag = "2")]
    pub content: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    /// Content type override to apply (if required). If omitted, the default rules of the Pact implementation
    /// will be used
    #[prost(enumeration = "body::ContentTypeHint", tag = "3")]
    pub content_type_hint: i32,
}
/// Nested message and enum types in `Body`.
pub mod body {
    /// Enum of content type override. This is a hint on how the content type should be treated.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ContentTypeHint {
        /// Determine the form of the content using the default rules of the Pact implementation
        Default = 0,
        /// Contents must always be treated as a text form
        Text = 1,
        /// Contents must always be treated as a binary form
        Binary = 2,
    }
    impl ContentTypeHint {
        /// 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::Default => "DEFAULT",
                Self::Text => "TEXT",
                Self::Binary => "BINARY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DEFAULT" => Some(Self::Default),
                "TEXT" => Some(Self::Text),
                "BINARY" => Some(Self::Binary),
                _ => None,
            }
        }
    }
}
/// Request to preform a comparison on an actual body given the expected one
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompareContentsRequest {
    /// Expected body from the Pact interaction
    #[prost(message, optional, tag = "1")]
    pub expected: ::core::option::Option<Body>,
    /// Actual received body
    #[prost(message, optional, tag = "2")]
    pub actual: ::core::option::Option<Body>,
    /// If unexpected keys or attributes should be allowed. Setting this to false results in additional keys or fields
    /// will cause a mismatch
    #[prost(bool, tag = "3")]
    pub allow_unexpected_keys: bool,
    /// Map of expressions to matching rules. The expressions follow the documented Pact matching rule expressions
    #[prost(map = "string, message", tag = "4")]
    pub rules: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        MatchingRules,
    >,
    /// Additional data added to the Pact/Interaction by the plugin
    #[prost(message, optional, tag = "5")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Context data provided by the test framework (carries testRunId for log correlation)
    #[prost(message, optional, tag = "6")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
/// Indicates that there was a mismatch with the content type
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ContentTypeMismatch {
    /// Expected content type (MIME format)
    #[prost(string, tag = "1")]
    pub expected: ::prost::alloc::string::String,
    /// Actual content type received (MIME format)
    #[prost(string, tag = "2")]
    pub actual: ::prost::alloc::string::String,
}
/// A mismatch for an particular item of content
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ContentMismatch {
    /// Expected data bytes
    #[prost(message, optional, tag = "1")]
    pub expected: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    /// Actual data bytes
    #[prost(message, optional, tag = "2")]
    pub actual: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    /// Description of the mismatch
    #[prost(string, tag = "3")]
    pub mismatch: ::prost::alloc::string::String,
    /// Path to the item that was matched. This is the value as per the documented Pact matching rule expressions.
    #[prost(string, tag = "4")]
    pub path: ::prost::alloc::string::String,
    /// Optional diff of the contents
    #[prost(string, tag = "5")]
    pub diff: ::prost::alloc::string::String,
    /// Part of the interaction that the mismatch is for: body, headers, metadata, etc.
    #[prost(string, tag = "6")]
    pub mismatch_type: ::prost::alloc::string::String,
}
/// List of content mismatches
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContentMismatches {
    #[prost(message, repeated, tag = "1")]
    pub mismatches: ::prost::alloc::vec::Vec<ContentMismatch>,
}
/// Response to the CompareContentsRequest with the results of the comparison
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompareContentsResponse {
    /// Error message if an error occurred. If this field is set, the remaining fields will be ignored and the
    /// verification marked as failed
    #[prost(string, tag = "1")]
    pub error: ::prost::alloc::string::String,
    /// There was a mismatch with the types of content. If this is set, the results may not be set.
    #[prost(message, optional, tag = "2")]
    pub type_mismatch: ::core::option::Option<ContentTypeMismatch>,
    /// Results of the match, keyed by matching rule expression
    #[prost(map = "string, message", tag = "3")]
    pub results: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ContentMismatches,
    >,
}
/// Request to configure/setup an interaction so that it can be verified later
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigureInteractionRequest {
    /// Content type of the interaction (MIME format)
    #[prost(string, tag = "1")]
    pub content_type: ::prost::alloc::string::String,
    /// This is data specified by the user in the consumer test
    #[prost(message, optional, tag = "2")]
    pub contents_config: ::core::option::Option<::prost_types::Struct>,
    /// Context data provided by the test framework (carries testRunId for log correlation)
    #[prost(message, optional, tag = "3")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
/// Represents a matching rule
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchingRule {
    /// Type of the matching rule
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Associated data for the matching rule
    #[prost(message, optional, tag = "2")]
    pub values: ::core::option::Option<::prost_types::Struct>,
}
/// List of matching rules
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchingRules {
    #[prost(message, repeated, tag = "1")]
    pub rule: ::prost::alloc::vec::Vec<MatchingRule>,
}
/// Example generator
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Generator {
    /// Type of generator
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Associated data for the generator
    #[prost(message, optional, tag = "2")]
    pub values: ::core::option::Option<::prost_types::Struct>,
}
/// Plugin configuration added to the pact file by the ConfigureInteraction step
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PluginConfiguration {
    /// Data to be persisted against the interaction
    #[prost(message, optional, tag = "1")]
    pub interaction_configuration: ::core::option::Option<::prost_types::Struct>,
    /// Data to be persisted in the Pact file metadata (Global data)
    #[prost(message, optional, tag = "2")]
    pub pact_configuration: ::core::option::Option<::prost_types::Struct>,
}
/// Structured interaction data sent to V2 plugins in place of raw pact JSON.
/// Contains only the data the plugin needs, eliminating the need for plugins
/// to parse full Pact documents.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InteractionContents {
    /// The V4 interaction type (e.g. "Synchronous/HTTP", "Synchronous/Messages")
    #[prost(string, tag = "1")]
    pub interaction_type: ::prost::alloc::string::String,
    /// Plugin configuration stored by the plugin during the consumer test
    #[prost(message, optional, tag = "2")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Consumer name, for result reporting and log correlation
    #[prost(string, tag = "3")]
    pub consumer: ::prost::alloc::string::String,
    /// Provider name, for result reporting and log correlation
    #[prost(string, tag = "4")]
    pub provider: ::prost::alloc::string::String,
}
/// Response to the configure/setup an interaction request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InteractionResponse {
    /// Contents for the interaction
    #[prost(message, optional, tag = "1")]
    pub contents: ::core::option::Option<Body>,
    /// All matching rules to apply
    #[prost(map = "string, message", tag = "2")]
    pub rules: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        MatchingRules,
    >,
    /// Generators to apply
    #[prost(map = "string, message", tag = "3")]
    pub generators: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        Generator,
    >,
    /// For message interactions, any metadata to be applied
    #[prost(message, optional, tag = "4")]
    pub message_metadata: ::core::option::Option<::prost_types::Struct>,
    /// Plugin specific data to be persisted in the pact file
    #[prost(message, optional, tag = "5")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Markdown/HTML formatted text representation of the interaction
    #[prost(string, tag = "6")]
    pub interaction_markup: ::prost::alloc::string::String,
    #[prost(enumeration = "interaction_response::MarkupType", tag = "7")]
    pub interaction_markup_type: i32,
    /// Description of what part this interaction belongs to (in the case of there being more than one, for instance,
    /// request/response messages)
    #[prost(string, tag = "8")]
    pub part_name: ::prost::alloc::string::String,
    /// All matching rules to apply to any message metadata
    #[prost(map = "string, message", tag = "9")]
    pub metadata_rules: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        MatchingRules,
    >,
    /// Generators to apply to any message metadata
    #[prost(map = "string, message", tag = "10")]
    pub metadata_generators: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        Generator,
    >,
}
/// Nested message and enum types in `InteractionResponse`.
pub mod interaction_response {
    /// Type of markup used
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MarkupType {
        /// CommonMark format
        CommonMark = 0,
        /// HTML format
        Html = 1,
    }
    impl MarkupType {
        /// 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::CommonMark => "COMMON_MARK",
                Self::Html => "HTML",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMMON_MARK" => Some(Self::CommonMark),
                "HTML" => Some(Self::Html),
                _ => None,
            }
        }
    }
}
/// Response to the configure/setup an interaction request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigureInteractionResponse {
    /// If an error occurred. In this case, the other fields will be ignored/not set
    #[prost(string, tag = "1")]
    pub error: ::prost::alloc::string::String,
    /// The actual response if no error occurred.
    #[prost(message, repeated, tag = "2")]
    pub interaction: ::prost::alloc::vec::Vec<InteractionResponse>,
    /// Plugin specific data to be persisted in the pact file
    #[prost(message, optional, tag = "3")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
}
/// Request to generate the contents using any defined generators
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateContentRequest {
    /// Original contents
    #[prost(message, optional, tag = "1")]
    pub contents: ::core::option::Option<Body>,
    /// Generators to apply
    #[prost(map = "string, message", tag = "2")]
    pub generators: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        Generator,
    >,
    /// Additional data added to the Pact/Interaction by the plugin
    #[prost(message, optional, tag = "3")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Context data provided by the test framework
    #[prost(message, optional, tag = "4")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
    #[prost(enumeration = "generate_content_request::TestMode", tag = "5")]
    pub test_mode: i32,
    #[prost(enumeration = "generate_content_request::ContentFor", tag = "6")]
    pub content_for: i32,
}
/// Nested message and enum types in `GenerateContentRequest`.
pub mod generate_content_request {
    /// The mode of the generation, if running from a consumer test or during provider verification
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TestMode {
        Unknown = 0,
        /// Running on the consumer side
        Consumer = 1,
        /// Running on the provider side
        Provider = 2,
    }
    impl TestMode {
        /// 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::Unknown => "Unknown",
                Self::Consumer => "Consumer",
                Self::Provider => "Provider",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Unknown" => Some(Self::Unknown),
                "Consumer" => Some(Self::Consumer),
                "Provider" => Some(Self::Provider),
                _ => None,
            }
        }
    }
    /// Which part the content is for
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ContentFor {
        Request = 0,
        Response = 1,
    }
    impl ContentFor {
        /// 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::Request => "Request",
                Self::Response => "Response",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Request" => Some(Self::Request),
                "Response" => Some(Self::Response),
                _ => None,
            }
        }
    }
}
/// Generated body/message response
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenerateContentResponse {
    #[prost(message, optional, tag = "1")]
    pub contents: ::core::option::Option<Body>,
}
/// A single value being matched or generated at the field/element level.
///
/// Each type Pact's matching rules discriminate has its own arm, rather than everything
/// JSON-representable sharing a google.protobuf.Value. That type carries a single number type (a
/// double), which would make `integer` and `decimal` indistinguishable and `type` wrong between a
/// whole number and a decimal - and these are exactly the rules whose job is to check the runtime
/// type of a value. Binary data has its own arm for the same reason: so it never has to be
/// stringified into a form it does not fit.
///
/// See proposal 006 (Field-level matchers and generators).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldValue {
    #[prost(oneof = "field_value::Value", tags = "1, 2, 3, 4, 5, 6, 7")]
    pub value: ::core::option::Option<field_value::Value>,
}
/// Nested message and enum types in `FieldValue`.
pub mod field_value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        /// A null value
        #[prost(enumeration = "::prost_types::NullValue", tag = "1")]
        NullValue(i32),
        /// A boolean
        #[prost(bool, tag = "2")]
        BooleanValue(bool),
        /// A string
        #[prost(string, tag = "3")]
        StringValue(::prost::alloc::string::String),
        /// A whole number
        #[prost(int64, tag = "4")]
        IntegerValue(i64),
        /// A number with a fractional part
        #[prost(double, tag = "5")]
        DecimalValue(f64),
        /// Raw bytes, for a value that is not representable as text
        #[prost(bytes, tag = "6")]
        BinaryValue(::prost::alloc::vec::Vec<u8>),
        /// A map or list, for a rule applied to a collection rather than a scalar. Numbers nested
        /// inside follow JSON semantics (every number is a double) - a collection rule only needs the
        /// shape and size of the collection, and the values inside it are matched by their own
        /// field-level calls, at their own paths, where they arrive under the arms above.
        #[prost(message, tag = "7")]
        StructuredValue(::prost_types::Value),
    }
}
/// Request to apply a plugin-provided matching rule to a single value. The plugin sees the value,
/// its path and the rule's own configuration, but not the document that contains it - a rule that
/// needs the surrounding document is a content matcher. See proposal 006.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchFieldRequest {
    /// Catalogue entry key of the rule being applied, e.g. "creditcard" for matcher/creditcard
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The rule as stored in the Pact file: its name and configured values
    #[prost(message, optional, tag = "2")]
    pub rule: ::core::option::Option<MatchingRule>,
    /// Path to the value being matched. This is the value as per the documented Pact matching rule expressions.
    #[prost(string, tag = "3")]
    pub path: ::prost::alloc::string::String,
    /// Part of the interaction the value came from: body, headers, metadata, query, path, status
    #[prost(string, tag = "4")]
    pub mismatch_type: ::prost::alloc::string::String,
    /// Expected value from the Pact interaction
    #[prost(message, optional, tag = "5")]
    pub expected: ::core::option::Option<FieldValue>,
    /// Actual value received
    #[prost(message, optional, tag = "6")]
    pub actual: ::core::option::Option<FieldValue>,
    /// Additional data added to the Pact/Interaction by the plugin
    #[prost(message, optional, tag = "7")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Context data provided by the test framework (carries testRunId for log correlation)
    #[prost(message, optional, tag = "8")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
/// Response to the MatchFieldRequest with the result of applying the rule
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchFieldResponse {
    /// Error message if the rule could not be applied at all. If this field is set, the remaining
    /// fields will be ignored and the verification marked as failed
    #[prost(string, tag = "1")]
    pub error: ::prost::alloc::string::String,
    /// Mismatches found. An empty list means the value matched. A mismatch with an empty path is
    /// reported against the path from the request
    #[prost(message, repeated, tag = "2")]
    pub mismatches: ::prost::alloc::vec::Vec<ContentMismatch>,
}
/// Request to generate a single value using a plugin-provided generator. Generators are pure
/// functions of this request: anything from the host they need arrives in testContext or is
/// fetched with an explicit callback. See proposal 006.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateFieldRequest {
    /// Catalogue entry key of the generator being applied, e.g. "creditcard" for generator/creditcard
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The generator as stored in the Pact file: its name and configured values
    #[prost(message, optional, tag = "2")]
    pub generator: ::core::option::Option<Generator>,
    /// Path to the value being generated. This is the value as per the documented Pact matching rule expressions.
    #[prost(string, tag = "3")]
    pub path: ::prost::alloc::string::String,
    /// The example value from the Pact interaction that the generated value replaces
    #[prost(message, optional, tag = "4")]
    pub example_value: ::core::option::Option<FieldValue>,
    /// Additional data added to the Pact/Interaction by the plugin
    #[prost(message, optional, tag = "5")]
    pub plugin_configuration: ::core::option::Option<PluginConfiguration>,
    /// Context data provided by the test framework
    #[prost(message, optional, tag = "6")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
    /// The mode of the generation, if running from a consumer test or during provider verification
    #[prost(enumeration = "generate_content_request::TestMode", tag = "7")]
    pub test_mode: i32,
}
/// Response to the GenerateFieldRequest with the generated value
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateFieldResponse {
    /// Error message if the value could not be generated. If this field is set, the value will be
    /// ignored
    #[prost(string, tag = "1")]
    pub error: ::prost::alloc::string::String,
    /// The generated value
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<FieldValue>,
}
/// Request to start a mock server
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMockServerRequest {
    /// Interface to bind to. Will default to the loopback adapter
    #[prost(string, tag = "1")]
    pub host_interface: ::prost::alloc::string::String,
    /// Port to bind to. Default (or a value of 0) get the OS to open a random port
    #[prost(uint32, tag = "2")]
    pub port: u32,
    /// If TLS should be used (if supported by the mock server)
    #[prost(bool, tag = "3")]
    pub tls: bool,
    /// Structured interaction data (replaces the pact JSON string from V1)
    #[prost(message, repeated, tag = "4")]
    pub interactions: ::prost::alloc::vec::Vec<InteractionContents>,
    /// Context data provided by the test framework
    #[prost(message, optional, tag = "5")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
/// Response to the start mock server request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartMockServerResponse {
    #[prost(oneof = "start_mock_server_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<start_mock_server_response::Response>,
}
/// Nested message and enum types in `StartMockServerResponse`.
pub mod start_mock_server_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Response {
        /// If an error occurred
        #[prost(string, tag = "1")]
        Error(::prost::alloc::string::String),
        /// Mock server details
        #[prost(message, tag = "2")]
        Details(super::MockServerDetails),
    }
}
/// Details on a running mock server
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MockServerDetails {
    /// Mock server unique ID
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Port the mock server is running on
    #[prost(uint32, tag = "2")]
    pub port: u32,
    /// IP address the mock server is bound to. Probably an IP6 address, but may be IP4
    #[prost(string, tag = "3")]
    pub address: ::prost::alloc::string::String,
}
/// Request for a running mock server by ID
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MockServerRequest {
    /// The server ID to shutdown
    #[prost(string, tag = "1")]
    pub server_key: ::prost::alloc::string::String,
}
/// Result of a request that the mock server received
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MockServerResult {
    /// service + method that was requested
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// If an error occurred trying to handle the request
    #[prost(string, tag = "2")]
    pub error: ::prost::alloc::string::String,
    /// Any mismatches that occurred
    #[prost(message, repeated, tag = "3")]
    pub mismatches: ::prost::alloc::vec::Vec<ContentMismatch>,
}
/// Matching results of the mock server.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MockServerResults {
    /// If the mock status is all ok
    #[prost(bool, tag = "1")]
    pub ok: bool,
    /// The results of the test run, will contain an entry for each request received by the mock server
    #[prost(message, repeated, tag = "2")]
    pub results: ::prost::alloc::vec::Vec<MockServerResult>,
}
/// Request to prepare an interaction for verification
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerificationPreparationRequest {
    /// Structured interaction data (replaces pact JSON + interactionKey from V1)
    #[prost(message, optional, tag = "1")]
    pub interaction_contents: ::core::option::Option<InteractionContents>,
    /// Any data supplied by the user to verify the interaction
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<::prost_types::Struct>,
    /// Context data provided by the test framework
    #[prost(message, optional, tag = "3")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
/// Request metadata value. Will either be a JSON-like value, or binary data
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetadataValue {
    #[prost(oneof = "metadata_value::Value", tags = "1, 2")]
    pub value: ::core::option::Option<metadata_value::Value>,
}
/// Nested message and enum types in `MetadataValue`.
pub mod metadata_value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "1")]
        NonBinaryValue(::prost_types::Value),
        #[prost(bytes, tag = "2")]
        BinaryValue(::prost::alloc::vec::Vec<u8>),
    }
}
/// Interaction request data to be sent or received for verification
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InteractionData {
    /// Request/Response body as bytes
    #[prost(message, optional, tag = "1")]
    pub body: ::core::option::Option<Body>,
    /// Metadata associated with the request/response
    #[prost(map = "string, message", tag = "2")]
    pub metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        MetadataValue,
    >,
}
/// Response for the prepare an interaction for verification request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerificationPreparationResponse {
    #[prost(oneof = "verification_preparation_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<verification_preparation_response::Response>,
}
/// Nested message and enum types in `VerificationPreparationResponse`.
pub mod verification_preparation_response {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        /// If an error occurred
        #[prost(string, tag = "1")]
        Error(::prost::alloc::string::String),
        /// Interaction data required to construct any request
        #[prost(message, tag = "2")]
        InteractionData(super::InteractionData),
    }
}
/// Request data to verify an interaction
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerifyInteractionRequest {
    /// Interaction data required to construct the request
    #[prost(message, optional, tag = "1")]
    pub interaction_data: ::core::option::Option<InteractionData>,
    /// Any data supplied by the user to verify the interaction
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<::prost_types::Struct>,
    /// Structured interaction data (replaces pact JSON + interactionKey from V1)
    #[prost(message, optional, tag = "3")]
    pub interaction_contents: ::core::option::Option<InteractionContents>,
    /// Context data provided by the test framework
    #[prost(message, optional, tag = "4")]
    pub test_context: ::core::option::Option<::prost_types::Struct>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VerificationResultItem {
    #[prost(oneof = "verification_result_item::Result", tags = "1, 2")]
    pub result: ::core::option::Option<verification_result_item::Result>,
}
/// Nested message and enum types in `VerificationResultItem`.
pub mod verification_result_item {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Result {
        #[prost(string, tag = "1")]
        Error(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Mismatch(super::ContentMismatch),
    }
}
/// Result of running the verification
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerificationResult {
    /// Was the verification successful?
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// Interaction data retrieved from the provider (optional)
    #[prost(message, optional, tag = "2")]
    pub response_data: ::core::option::Option<InteractionData>,
    /// Any mismatches that occurred
    #[prost(message, repeated, tag = "3")]
    pub mismatches: ::prost::alloc::vec::Vec<VerificationResultItem>,
    /// Output for the verification to display to the user
    #[prost(string, repeated, tag = "4")]
    pub output: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Result of running the verification
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VerifyInteractionResponse {
    #[prost(oneof = "verify_interaction_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<verify_interaction_response::Response>,
}
/// Nested message and enum types in `VerifyInteractionResponse`.
pub mod verify_interaction_response {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        /// If an error occurred trying to run the verification
        #[prost(string, tag = "1")]
        Error(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Result(super::VerificationResult),
    }
}
/// Structured log record emitted by a plugin and forwarded to the driver via the Log RPC
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LogMessage {
    /// Plugin instance UUID (from InitPluginRequest.pluginInstanceId)
    #[prost(string, tag = "1")]
    pub plugin_instance_id: ::prost::alloc::string::String,
    /// Test run UUID (from testContext\["testRunId"\], if available)
    #[prost(string, tag = "2")]
    pub test_run_id: ::prost::alloc::string::String,
    /// Log level: TRACE, DEBUG, INFO, WARN, ERROR
    #[prost(string, tag = "3")]
    pub level: ::prost::alloc::string::String,
    /// Human-readable log message
    #[prost(string, tag = "4")]
    pub message: ::prost::alloc::string::String,
    /// Logger name / module path (e.g. "pact_csv_plugin::matching")
    #[prost(string, tag = "5")]
    pub target: ::prost::alloc::string::String,
    /// Unix epoch milliseconds
    #[prost(int64, tag = "6")]
    pub timestamp_ms: i64,
}
/// Callback request from a plugin to invoke a content matcher capability - host-provided or
/// owned by another plugin - resolved by catalogue entry key. See proposal 007 (Driver-plugin
/// callback model).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostCompareContentsRequest {
    /// Catalogue entry key identifying the capability to invoke, e.g. "xml" for content-matcher/xml
    #[prost(string, tag = "1")]
    pub entry_key: ::prost::alloc::string::String,
    /// The comparison request, in the same shape as PactPlugin.CompareContents
    #[prost(message, optional, tag = "2")]
    pub request: ::core::option::Option<CompareContentsRequest>,
}
/// Callback request from a plugin to invoke a content generator capability - host-provided or
/// owned by another plugin - resolved by catalogue entry key. See proposal 007 (Driver-plugin
/// callback model).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostGenerateContentRequest {
    /// Catalogue entry key identifying the capability to invoke, e.g. "xml" for content-generator/xml
    #[prost(string, tag = "1")]
    pub entry_key: ::prost::alloc::string::String,
    /// The generation request, in the same shape as PactPlugin.GenerateContent
    #[prost(message, optional, tag = "2")]
    pub request: ::core::option::Option<GenerateContentRequest>,
}
/// Callback request from a plugin to invoke a field-level matching rule - host-provided (one of the
/// standard Pact rules) or owned by another plugin - resolved by catalogue entry key. See proposals
/// 006 (Field-level matchers and generators) and 007 (Driver-plugin callback model).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostMatchFieldRequest {
    /// Catalogue entry key identifying the rule to invoke. Either the rule name on its own ("type",
    /// "content-type" - the same string MatchFieldRequest.rule.type carries), or more of the
    /// catalogue key to disambiguate it ("matcher/type", "core/matcher/type").
    #[prost(string, tag = "1")]
    pub entry_key: ::prost::alloc::string::String,
    /// The match request, in the same shape as PactPlugin.MatchField
    #[prost(message, optional, tag = "2")]
    pub request: ::core::option::Option<MatchFieldRequest>,
}
/// Callback request from a plugin to invoke a field-level generator - host-provided or owned by
/// another plugin - resolved by catalogue entry key. See proposals 006 and 007.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostGenerateFieldRequest {
    /// Catalogue entry key identifying the generator to invoke, e.g. "date" or "generator/date".
    /// See HostMatchFieldRequest.entryKey.
    #[prost(string, tag = "1")]
    pub entry_key: ::prost::alloc::string::String,
    /// The generation request, in the same shape as PactPlugin.GenerateField
    #[prost(message, optional, tag = "2")]
    pub request: ::core::option::Option<GenerateFieldRequest>,
}
/// Generated client implementations.
pub mod plugin_host_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Driver-side service implemented by the driver and called by plugins
    #[derive(Debug, Clone)]
    pub struct PluginHostClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PluginHostClient<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> PluginHostClient<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,
        ) -> PluginHostClient<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,
        {
            PluginHostClient::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
        }
        /// Forward a structured log record from the plugin to the driver's logging framework
        pub async fn log(
            &mut self,
            request: impl tonic::IntoRequest<super::LogMessage>,
        ) -> std::result::Result<tonic::Response<()>, 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(
                "/io.pact.plugin.v2.PluginHost/Log",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("io.pact.plugin.v2.PluginHost", "Log"));
            self.inner.unary(req, path, codec).await
        }
        /// Invoke a content matcher capability by catalogue entry key. The driver resolves the key to
        /// either a host-registered core handler or another running plugin. See proposal 007.
        pub async fn compare_contents(
            &mut self,
            request: impl tonic::IntoRequest<super::HostCompareContentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompareContentsResponse>,
            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(
                "/io.pact.plugin.v2.PluginHost/CompareContents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PluginHost", "CompareContents"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Invoke a content generator capability by catalogue entry key. The driver resolves the key to
        /// either a host-registered core handler or another running plugin. See proposal 007.
        pub async fn generate_content(
            &mut self,
            request: impl tonic::IntoRequest<super::HostGenerateContentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateContentResponse>,
            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(
                "/io.pact.plugin.v2.PluginHost/GenerateContent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PluginHost", "GenerateContent"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Invoke a field-level matching rule by catalogue entry key, resolved the same way. This is how
        /// a plugin delegates one field of a document it owns to a standard Pact rule instead of
        /// reimplementing it. See proposals 006 and 009.
        pub async fn match_field(
            &mut self,
            request: impl tonic::IntoRequest<super::HostMatchFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MatchFieldResponse>,
            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(
                "/io.pact.plugin.v2.PluginHost/MatchField",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("io.pact.plugin.v2.PluginHost", "MatchField"));
            self.inner.unary(req, path, codec).await
        }
        /// Invoke a field-level generator by catalogue entry key, resolved the same way.
        /// See proposals 006 and 009.
        pub async fn generate_field(
            &mut self,
            request: impl tonic::IntoRequest<super::HostGenerateFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateFieldResponse>,
            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(
                "/io.pact.plugin.v2.PluginHost/GenerateField",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PluginHost", "GenerateField"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod plugin_host_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with PluginHostServer.
    #[async_trait]
    pub trait PluginHost: std::marker::Send + std::marker::Sync + 'static {
        /// Forward a structured log record from the plugin to the driver's logging framework
        async fn log(
            &self,
            request: tonic::Request<super::LogMessage>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Invoke a content matcher capability by catalogue entry key. The driver resolves the key to
        /// either a host-registered core handler or another running plugin. See proposal 007.
        async fn compare_contents(
            &self,
            request: tonic::Request<super::HostCompareContentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompareContentsResponse>,
            tonic::Status,
        >;
        /// Invoke a content generator capability by catalogue entry key. The driver resolves the key to
        /// either a host-registered core handler or another running plugin. See proposal 007.
        async fn generate_content(
            &self,
            request: tonic::Request<super::HostGenerateContentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateContentResponse>,
            tonic::Status,
        >;
        /// Invoke a field-level matching rule by catalogue entry key, resolved the same way. This is how
        /// a plugin delegates one field of a document it owns to a standard Pact rule instead of
        /// reimplementing it. See proposals 006 and 009.
        async fn match_field(
            &self,
            request: tonic::Request<super::HostMatchFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MatchFieldResponse>,
            tonic::Status,
        >;
        /// Invoke a field-level generator by catalogue entry key, resolved the same way.
        /// See proposals 006 and 009.
        async fn generate_field(
            &self,
            request: tonic::Request<super::HostGenerateFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateFieldResponse>,
            tonic::Status,
        >;
    }
    /// Driver-side service implemented by the driver and called by plugins
    #[derive(Debug)]
    pub struct PluginHostServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> PluginHostServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for PluginHostServer<T>
    where
        T: PluginHost,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/io.pact.plugin.v2.PluginHost/Log" => {
                    #[allow(non_camel_case_types)]
                    struct LogSvc<T: PluginHost>(pub Arc<T>);
                    impl<T: PluginHost> tonic::server::UnaryService<super::LogMessage>
                    for LogSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::LogMessage>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PluginHost>::log(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = LogSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PluginHost/CompareContents" => {
                    #[allow(non_camel_case_types)]
                    struct CompareContentsSvc<T: PluginHost>(pub Arc<T>);
                    impl<
                        T: PluginHost,
                    > tonic::server::UnaryService<super::HostCompareContentsRequest>
                    for CompareContentsSvc<T> {
                        type Response = super::CompareContentsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HostCompareContentsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PluginHost>::compare_contents(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CompareContentsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PluginHost/GenerateContent" => {
                    #[allow(non_camel_case_types)]
                    struct GenerateContentSvc<T: PluginHost>(pub Arc<T>);
                    impl<
                        T: PluginHost,
                    > tonic::server::UnaryService<super::HostGenerateContentRequest>
                    for GenerateContentSvc<T> {
                        type Response = super::GenerateContentResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HostGenerateContentRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PluginHost>::generate_content(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GenerateContentSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PluginHost/MatchField" => {
                    #[allow(non_camel_case_types)]
                    struct MatchFieldSvc<T: PluginHost>(pub Arc<T>);
                    impl<
                        T: PluginHost,
                    > tonic::server::UnaryService<super::HostMatchFieldRequest>
                    for MatchFieldSvc<T> {
                        type Response = super::MatchFieldResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HostMatchFieldRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PluginHost>::match_field(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = MatchFieldSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PluginHost/GenerateField" => {
                    #[allow(non_camel_case_types)]
                    struct GenerateFieldSvc<T: PluginHost>(pub Arc<T>);
                    impl<
                        T: PluginHost,
                    > tonic::server::UnaryService<super::HostGenerateFieldRequest>
                    for GenerateFieldSvc<T> {
                        type Response = super::GenerateFieldResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HostGenerateFieldRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PluginHost>::generate_field(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GenerateFieldSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for PluginHostServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "io.pact.plugin.v2.PluginHost";
    impl<T> tonic::server::NamedService for PluginHostServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Generated client implementations.
pub mod pact_plugin_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct PactPluginClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PactPluginClient<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> PactPluginClient<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,
        ) -> PactPluginClient<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,
        {
            PactPluginClient::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
        }
        /// Check that the plugin loaded OK. Returns the catalogue entries describing what the plugin provides
        pub async fn init_plugin(
            &mut self,
            request: impl tonic::IntoRequest<super::InitPluginRequest>,
        ) -> std::result::Result<
            tonic::Response<super::InitPluginResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/InitPlugin",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "InitPlugin"));
            self.inner.unary(req, path, codec).await
        }
        /// Updated catalogue. This will be sent when the core catalogue has been updated (probably by a plugin loading).
        pub async fn update_catalogue(
            &mut self,
            request: impl tonic::IntoRequest<super::Catalogue>,
        ) -> std::result::Result<tonic::Response<()>, 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(
                "/io.pact.plugin.v2.PactPlugin/UpdateCatalogue",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "UpdateCatalogue"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Request to perform a comparison of some contents (matching request)
        pub async fn compare_contents(
            &mut self,
            request: impl tonic::IntoRequest<super::CompareContentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompareContentsResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/CompareContents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "CompareContents"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Request to configure/setup the interaction for later verification. Data returned will be persisted in the pact file.
        pub async fn configure_interaction(
            &mut self,
            request: impl tonic::IntoRequest<super::ConfigureInteractionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ConfigureInteractionResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/ConfigureInteraction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "io.pact.plugin.v2.PactPlugin",
                        "ConfigureInteraction",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Request to generate the content using any defined generators
        pub async fn generate_content(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateContentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateContentResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/GenerateContent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "GenerateContent"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Apply a plugin-provided matching rule to a single value. Required for any plugin that
        /// registers a MATCHER catalogue entry. See proposal 006 (Field-level matchers and generators).
        pub async fn match_field(
            &mut self,
            request: impl tonic::IntoRequest<super::MatchFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MatchFieldResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/MatchField",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "MatchField"));
            self.inner.unary(req, path, codec).await
        }
        /// Apply a plugin-provided generator to a single value. Required for any plugin that registers
        /// a GENERATOR catalogue entry. See proposal 006.
        pub async fn generate_field(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateFieldResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/GenerateField",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "GenerateField"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start a mock server
        pub async fn start_mock_server(
            &mut self,
            request: impl tonic::IntoRequest<super::StartMockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartMockServerResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/StartMockServer",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "StartMockServer"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Shutdown a running mock server
        pub async fn shutdown_mock_server(
            &mut self,
            request: impl tonic::IntoRequest<super::MockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MockServerResults>,
            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(
                "/io.pact.plugin.v2.PactPlugin/ShutdownMockServer",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "ShutdownMockServer"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get the matching results from a running mock server
        pub async fn get_mock_server_results(
            &mut self,
            request: impl tonic::IntoRequest<super::MockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MockServerResults>,
            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(
                "/io.pact.plugin.v2.PactPlugin/GetMockServerResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "io.pact.plugin.v2.PactPlugin",
                        "GetMockServerResults",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Prepare an interaction for verification. This should return any data required to construct any request
        /// so that it can be amended before the verification is run
        pub async fn prepare_interaction_for_verification(
            &mut self,
            request: impl tonic::IntoRequest<super::VerificationPreparationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerificationPreparationResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/PrepareInteractionForVerification",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "io.pact.plugin.v2.PactPlugin",
                        "PrepareInteractionForVerification",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Execute the verification for the interaction.
        pub async fn verify_interaction(
            &mut self,
            request: impl tonic::IntoRequest<super::VerifyInteractionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerifyInteractionResponse>,
            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(
                "/io.pact.plugin.v2.PactPlugin/VerifyInteraction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("io.pact.plugin.v2.PactPlugin", "VerifyInteraction"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod pact_plugin_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with PactPluginServer.
    #[async_trait]
    pub trait PactPlugin: std::marker::Send + std::marker::Sync + 'static {
        /// Check that the plugin loaded OK. Returns the catalogue entries describing what the plugin provides
        async fn init_plugin(
            &self,
            request: tonic::Request<super::InitPluginRequest>,
        ) -> std::result::Result<
            tonic::Response<super::InitPluginResponse>,
            tonic::Status,
        >;
        /// Updated catalogue. This will be sent when the core catalogue has been updated (probably by a plugin loading).
        async fn update_catalogue(
            &self,
            request: tonic::Request<super::Catalogue>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Request to perform a comparison of some contents (matching request)
        async fn compare_contents(
            &self,
            request: tonic::Request<super::CompareContentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompareContentsResponse>,
            tonic::Status,
        >;
        /// Request to configure/setup the interaction for later verification. Data returned will be persisted in the pact file.
        async fn configure_interaction(
            &self,
            request: tonic::Request<super::ConfigureInteractionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ConfigureInteractionResponse>,
            tonic::Status,
        >;
        /// Request to generate the content using any defined generators
        async fn generate_content(
            &self,
            request: tonic::Request<super::GenerateContentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateContentResponse>,
            tonic::Status,
        >;
        /// Apply a plugin-provided matching rule to a single value. Required for any plugin that
        /// registers a MATCHER catalogue entry. See proposal 006 (Field-level matchers and generators).
        async fn match_field(
            &self,
            request: tonic::Request<super::MatchFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MatchFieldResponse>,
            tonic::Status,
        >;
        /// Apply a plugin-provided generator to a single value. Required for any plugin that registers
        /// a GENERATOR catalogue entry. See proposal 006.
        async fn generate_field(
            &self,
            request: tonic::Request<super::GenerateFieldRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateFieldResponse>,
            tonic::Status,
        >;
        /// Start a mock server
        async fn start_mock_server(
            &self,
            request: tonic::Request<super::StartMockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartMockServerResponse>,
            tonic::Status,
        >;
        /// Shutdown a running mock server
        async fn shutdown_mock_server(
            &self,
            request: tonic::Request<super::MockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MockServerResults>,
            tonic::Status,
        >;
        /// Get the matching results from a running mock server
        async fn get_mock_server_results(
            &self,
            request: tonic::Request<super::MockServerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MockServerResults>,
            tonic::Status,
        >;
        /// Prepare an interaction for verification. This should return any data required to construct any request
        /// so that it can be amended before the verification is run
        async fn prepare_interaction_for_verification(
            &self,
            request: tonic::Request<super::VerificationPreparationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerificationPreparationResponse>,
            tonic::Status,
        >;
        /// Execute the verification for the interaction.
        async fn verify_interaction(
            &self,
            request: tonic::Request<super::VerifyInteractionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VerifyInteractionResponse>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct PactPluginServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> PactPluginServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for PactPluginServer<T>
    where
        T: PactPlugin,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/io.pact.plugin.v2.PactPlugin/InitPlugin" => {
                    #[allow(non_camel_case_types)]
                    struct InitPluginSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::InitPluginRequest>
                    for InitPluginSvc<T> {
                        type Response = super::InitPluginResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::InitPluginRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::init_plugin(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = InitPluginSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/UpdateCatalogue" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateCatalogueSvc<T: PactPlugin>(pub Arc<T>);
                    impl<T: PactPlugin> tonic::server::UnaryService<super::Catalogue>
                    for UpdateCatalogueSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Catalogue>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::update_catalogue(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateCatalogueSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/CompareContents" => {
                    #[allow(non_camel_case_types)]
                    struct CompareContentsSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::CompareContentsRequest>
                    for CompareContentsSvc<T> {
                        type Response = super::CompareContentsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CompareContentsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::compare_contents(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CompareContentsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/ConfigureInteraction" => {
                    #[allow(non_camel_case_types)]
                    struct ConfigureInteractionSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::ConfigureInteractionRequest>
                    for ConfigureInteractionSvc<T> {
                        type Response = super::ConfigureInteractionResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ConfigureInteractionRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::configure_interaction(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ConfigureInteractionSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/GenerateContent" => {
                    #[allow(non_camel_case_types)]
                    struct GenerateContentSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::GenerateContentRequest>
                    for GenerateContentSvc<T> {
                        type Response = super::GenerateContentResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenerateContentRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::generate_content(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GenerateContentSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/MatchField" => {
                    #[allow(non_camel_case_types)]
                    struct MatchFieldSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::MatchFieldRequest>
                    for MatchFieldSvc<T> {
                        type Response = super::MatchFieldResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::MatchFieldRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::match_field(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = MatchFieldSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/GenerateField" => {
                    #[allow(non_camel_case_types)]
                    struct GenerateFieldSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::GenerateFieldRequest>
                    for GenerateFieldSvc<T> {
                        type Response = super::GenerateFieldResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenerateFieldRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::generate_field(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GenerateFieldSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/StartMockServer" => {
                    #[allow(non_camel_case_types)]
                    struct StartMockServerSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::StartMockServerRequest>
                    for StartMockServerSvc<T> {
                        type Response = super::StartMockServerResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StartMockServerRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::start_mock_server(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = StartMockServerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/ShutdownMockServer" => {
                    #[allow(non_camel_case_types)]
                    struct ShutdownMockServerSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::MockServerRequest>
                    for ShutdownMockServerSvc<T> {
                        type Response = super::MockServerResults;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::MockServerRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::shutdown_mock_server(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ShutdownMockServerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/GetMockServerResults" => {
                    #[allow(non_camel_case_types)]
                    struct GetMockServerResultsSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::MockServerRequest>
                    for GetMockServerResultsSvc<T> {
                        type Response = super::MockServerResults;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::MockServerRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::get_mock_server_results(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetMockServerResultsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/PrepareInteractionForVerification" => {
                    #[allow(non_camel_case_types)]
                    struct PrepareInteractionForVerificationSvc<T: PactPlugin>(
                        pub Arc<T>,
                    );
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::VerificationPreparationRequest>
                    for PrepareInteractionForVerificationSvc<T> {
                        type Response = super::VerificationPreparationResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::VerificationPreparationRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::prepare_interaction_for_verification(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = PrepareInteractionForVerificationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/io.pact.plugin.v2.PactPlugin/VerifyInteraction" => {
                    #[allow(non_camel_case_types)]
                    struct VerifyInteractionSvc<T: PactPlugin>(pub Arc<T>);
                    impl<
                        T: PactPlugin,
                    > tonic::server::UnaryService<super::VerifyInteractionRequest>
                    for VerifyInteractionSvc<T> {
                        type Response = super::VerifyInteractionResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::VerifyInteractionRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as PactPlugin>::verify_interaction(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = VerifyInteractionSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for PactPluginServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "io.pact.plugin.v2.PactPlugin";
    impl<T> tonic::server::NamedService for PactPluginServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}