#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Message {
    /// This message should not have any technical knowledge requirements to be understood
    /// and provide a suggested action for how to avoid. Examples:
    ///
    /// A server throws an exception -> "Please retry your operation, and if it fails again,
    /// contact customer support".
    ///
    /// A bond security is set as having a fixed coupon, but a reference index and spread is
    /// provided -> "A fixed income bond needs a static coupon, and shouldn't have an index
    /// or spread provided."
    #[prost(string, tag = "1")]
    pub message_for_user: ::prost::alloc::string::String,
    /// This message can be used to instruct a developer operating on APIs how best to approach
    /// resolving this issue.
    /// A server throws an exception -> "The <x> service timed out or rejected this message.
    ///   Please consider whether you are spamming the backend server and reach out to developer
    ///   support to see how to optimize your usage".
    #[prost(string, tag = "2")]
    pub message_for_developer: ::prost::alloc::string::String,
}
/// An error is used for situations where a request cannot be processed successfully, either
/// from a technical perspective or a business perspective.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorProto {
    #[prost(enumeration = "ErrorCode", tag = "1")]
    pub code: i32,
    #[prost(message, optional, tag = "2")]
    pub detail: ::core::option::Option<Message>,
}
/// Warnings can have error codes, if it is useful in categorizing the severity of the warning.
/// For example a warning may be thrown if 2 securities are created with the same identifier.
/// Another example may be usage of a deprecated API.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WarningProto {
    #[prost(enumeration = "ErrorCode", tag = "1")]
    pub code: i32,
    #[prost(message, optional, tag = "2")]
    pub detail: ::core::option::Option<Message>,
}
/// Error codes are defined to allow clients to programmatically
/// respond to issues. The bar for creating a new error code should
/// be that the
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ErrorCode {
    UnknownError = 0,
    /// TO THINK ABOUT
    Warning = 1,
}
impl ErrorCode {
    /// 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 {
            ErrorCode::UnknownError => "UNKNOWN_ERROR",
            ErrorCode::Warning => "WARNING",
        }
    }
    /// 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_ERROR" => Some(Self::UnknownError),
            "WARNING" => Some(Self::Warning),
            _ => None,
        }
    }
}
/// GRPC error codes are used to indicate if there was any substantial issue. They cover situations
/// like OK, Cancelled, AlreadyExists, InvalidArgument, ResourceExhausted, Unauthenticated, etc.
/// Ideally Fintekkers will not introduce another concept on top of that to avoid complicating the
/// solution.
///
/// If there are any errors, the GRPC response should not return OK (code=0).
/// Warnings may be returned at any time, and may be done even with successful responses.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SummaryProto {
    #[prost(message, repeated, tag = "1")]
    pub errors: ::prost::alloc::vec::Vec<ErrorProto>,
    #[prost(message, repeated, tag = "2")]
    pub warnings: ::prost::alloc::vec::Vec<WarningProto>,
}
