impl serde::Serialize for Agent {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.catalog_name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if !self.full_name.is_empty() {
len += 1;
}
if !self.agent_id.is_empty() {
len += 1;
}
if self.invocation_protocol != 0 {
len += 1;
}
if !self.endpoint.is_empty() {
len += 1;
}
if self.description.is_some() {
len += 1;
}
if !self.capabilities.is_empty() {
len += 1;
}
if self.input_schema.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.created_at.is_some() {
len += 1;
}
if self.created_by.is_some() {
len += 1;
}
if self.updated_at.is_some() {
len += 1;
}
if self.updated_by.is_some() {
len += 1;
}
if self.metastore_id.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.Agent", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if !self.full_name.is_empty() {
struct_ser.serialize_field("full_name", &self.full_name)?;
}
if !self.agent_id.is_empty() {
struct_ser.serialize_field("agent_id", &self.agent_id)?;
}
if self.invocation_protocol != 0 {
let v = InvocationProtocol::try_from(self.invocation_protocol)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.invocation_protocol)))?;
struct_ser.serialize_field("invocation_protocol", &v)?;
}
if !self.endpoint.is_empty() {
struct_ser.serialize_field("endpoint", &self.endpoint)?;
}
if let Some(v) = self.description.as_ref() {
struct_ser.serialize_field("description", v)?;
}
if !self.capabilities.is_empty() {
struct_ser.serialize_field("capabilities", &self.capabilities)?;
}
if let Some(v) = self.input_schema.as_ref() {
struct_ser.serialize_field("input_schema", v)?;
}
if let Some(v) = self.owner.as_ref() {
struct_ser.serialize_field("owner", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.created_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("created_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.created_by.as_ref() {
struct_ser.serialize_field("created_by", v)?;
}
if let Some(v) = self.updated_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("updated_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.updated_by.as_ref() {
struct_ser.serialize_field("updated_by", v)?;
}
if let Some(v) = self.metastore_id.as_ref() {
struct_ser.serialize_field("metastore_id", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Agent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"catalog_name",
"catalogName",
"schema_name",
"schemaName",
"full_name",
"fullName",
"agent_id",
"agentId",
"invocation_protocol",
"invocationProtocol",
"endpoint",
"description",
"capabilities",
"input_schema",
"inputSchema",
"owner",
"comment",
"created_at",
"createdAt",
"created_by",
"createdBy",
"updated_at",
"updatedAt",
"updated_by",
"updatedBy",
"metastore_id",
"metastoreId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
CatalogName,
SchemaName,
FullName,
AgentId,
InvocationProtocol,
Endpoint,
Description,
Capabilities,
InputSchema,
Owner,
Comment,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
MetastoreId,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"fullName" | "full_name" => Ok(GeneratedField::FullName),
"agentId" | "agent_id" => Ok(GeneratedField::AgentId),
"invocationProtocol" | "invocation_protocol" => Ok(GeneratedField::InvocationProtocol),
"endpoint" => Ok(GeneratedField::Endpoint),
"description" => Ok(GeneratedField::Description),
"capabilities" => Ok(GeneratedField::Capabilities),
"inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
"owner" => Ok(GeneratedField::Owner),
"comment" => Ok(GeneratedField::Comment),
"createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
"createdBy" | "created_by" => Ok(GeneratedField::CreatedBy),
"updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
"updatedBy" | "updated_by" => Ok(GeneratedField::UpdatedBy),
"metastoreId" | "metastore_id" => Ok(GeneratedField::MetastoreId),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Agent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.Agent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Agent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut catalog_name__ = None;
let mut schema_name__ = None;
let mut full_name__ = None;
let mut agent_id__ = None;
let mut invocation_protocol__ = None;
let mut endpoint__ = None;
let mut description__ = None;
let mut capabilities__ = None;
let mut input_schema__ = None;
let mut owner__ = None;
let mut comment__ = None;
let mut created_at__ = None;
let mut created_by__ = None;
let mut updated_at__ = None;
let mut updated_by__ = None;
let mut metastore_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::FullName => {
if full_name__.is_some() {
return Err(serde::de::Error::duplicate_field("fullName"));
}
full_name__ = Some(map_.next_value()?);
}
GeneratedField::AgentId => {
if agent_id__.is_some() {
return Err(serde::de::Error::duplicate_field("agentId"));
}
agent_id__ = Some(map_.next_value()?);
}
GeneratedField::InvocationProtocol => {
if invocation_protocol__.is_some() {
return Err(serde::de::Error::duplicate_field("invocationProtocol"));
}
invocation_protocol__ = Some(map_.next_value::<InvocationProtocol>()? as i32);
}
GeneratedField::Endpoint => {
if endpoint__.is_some() {
return Err(serde::de::Error::duplicate_field("endpoint"));
}
endpoint__ = Some(map_.next_value()?);
}
GeneratedField::Description => {
if description__.is_some() {
return Err(serde::de::Error::duplicate_field("description"));
}
description__ = map_.next_value()?;
}
GeneratedField::Capabilities => {
if capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("capabilities"));
}
capabilities__ = Some(map_.next_value()?);
}
GeneratedField::InputSchema => {
if input_schema__.is_some() {
return Err(serde::de::Error::duplicate_field("inputSchema"));
}
input_schema__ = map_.next_value()?;
}
GeneratedField::Owner => {
if owner__.is_some() {
return Err(serde::de::Error::duplicate_field("owner"));
}
owner__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::CreatedAt => {
if created_at__.is_some() {
return Err(serde::de::Error::duplicate_field("createdAt"));
}
created_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::CreatedBy => {
if created_by__.is_some() {
return Err(serde::de::Error::duplicate_field("createdBy"));
}
created_by__ = map_.next_value()?;
}
GeneratedField::UpdatedAt => {
if updated_at__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedAt"));
}
updated_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::UpdatedBy => {
if updated_by__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedBy"));
}
updated_by__ = map_.next_value()?;
}
GeneratedField::MetastoreId => {
if metastore_id__.is_some() {
return Err(serde::de::Error::duplicate_field("metastoreId"));
}
metastore_id__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Agent {
name: name__.unwrap_or_default(),
catalog_name: catalog_name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
full_name: full_name__.unwrap_or_default(),
agent_id: agent_id__.unwrap_or_default(),
invocation_protocol: invocation_protocol__.unwrap_or_default(),
endpoint: endpoint__.unwrap_or_default(),
description: description__,
capabilities: capabilities__.unwrap_or_default(),
input_schema: input_schema__,
owner: owner__,
comment: comment__,
created_at: created_at__,
created_by: created_by__,
updated_at: updated_at__,
updated_by: updated_by__,
metastore_id: metastore_id__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.Agent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreateAgentRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.catalog_name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
if self.invocation_protocol != 0 {
len += 1;
}
if !self.endpoint.is_empty() {
len += 1;
}
if self.description.is_some() {
len += 1;
}
if !self.capabilities.is_empty() {
len += 1;
}
if self.input_schema.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.CreateAgentRequest", len)?;
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if self.invocation_protocol != 0 {
let v = InvocationProtocol::try_from(self.invocation_protocol)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.invocation_protocol)))?;
struct_ser.serialize_field("invocation_protocol", &v)?;
}
if !self.endpoint.is_empty() {
struct_ser.serialize_field("endpoint", &self.endpoint)?;
}
if let Some(v) = self.description.as_ref() {
struct_ser.serialize_field("description", v)?;
}
if !self.capabilities.is_empty() {
struct_ser.serialize_field("capabilities", &self.capabilities)?;
}
if let Some(v) = self.input_schema.as_ref() {
struct_ser.serialize_field("input_schema", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateAgentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"catalog_name",
"catalogName",
"schema_name",
"schemaName",
"name",
"invocation_protocol",
"invocationProtocol",
"endpoint",
"description",
"capabilities",
"input_schema",
"inputSchema",
"comment",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CatalogName,
SchemaName,
Name,
InvocationProtocol,
Endpoint,
Description,
Capabilities,
InputSchema,
Comment,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"name" => Ok(GeneratedField::Name),
"invocationProtocol" | "invocation_protocol" => Ok(GeneratedField::InvocationProtocol),
"endpoint" => Ok(GeneratedField::Endpoint),
"description" => Ok(GeneratedField::Description),
"capabilities" => Ok(GeneratedField::Capabilities),
"inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
"comment" => Ok(GeneratedField::Comment),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateAgentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.CreateAgentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateAgentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut catalog_name__ = None;
let mut schema_name__ = None;
let mut name__ = None;
let mut invocation_protocol__ = None;
let mut endpoint__ = None;
let mut description__ = None;
let mut capabilities__ = None;
let mut input_schema__ = None;
let mut comment__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::InvocationProtocol => {
if invocation_protocol__.is_some() {
return Err(serde::de::Error::duplicate_field("invocationProtocol"));
}
invocation_protocol__ = Some(map_.next_value::<InvocationProtocol>()? as i32);
}
GeneratedField::Endpoint => {
if endpoint__.is_some() {
return Err(serde::de::Error::duplicate_field("endpoint"));
}
endpoint__ = Some(map_.next_value()?);
}
GeneratedField::Description => {
if description__.is_some() {
return Err(serde::de::Error::duplicate_field("description"));
}
description__ = map_.next_value()?;
}
GeneratedField::Capabilities => {
if capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("capabilities"));
}
capabilities__ = Some(map_.next_value()?);
}
GeneratedField::InputSchema => {
if input_schema__.is_some() {
return Err(serde::de::Error::duplicate_field("inputSchema"));
}
input_schema__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateAgentRequest {
catalog_name: catalog_name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
name: name__.unwrap_or_default(),
invocation_protocol: invocation_protocol__.unwrap_or_default(),
endpoint: endpoint__.unwrap_or_default(),
description: description__,
capabilities: capabilities__.unwrap_or_default(),
input_schema: input_schema__,
comment: comment__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.CreateAgentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteAgentRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.DeleteAgentRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteAgentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteAgentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.DeleteAgentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteAgentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DeleteAgentRequest {
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.DeleteAgentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetAgentRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if self.include_browse.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.GetAgentRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.include_browse.as_ref() {
struct_ser.serialize_field("include_browse", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetAgentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"include_browse",
"includeBrowse",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
IncludeBrowse,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"includeBrowse" | "include_browse" => Ok(GeneratedField::IncludeBrowse),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetAgentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.GetAgentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAgentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut include_browse__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::IncludeBrowse => {
if include_browse__.is_some() {
return Err(serde::de::Error::duplicate_field("includeBrowse"));
}
include_browse__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetAgentRequest {
name: name__.unwrap_or_default(),
include_browse: include_browse__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.GetAgentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for InvocationProtocol {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "INVOCATION_PROTOCOL_UNSPECIFIED",
Self::Mcp => "MCP",
Self::A2a => "A2A",
Self::Openai => "OPENAI",
Self::Anthropic => "ANTHROPIC",
Self::Rest => "REST",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for InvocationProtocol {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"INVOCATION_PROTOCOL_UNSPECIFIED",
"MCP",
"A2A",
"OPENAI",
"ANTHROPIC",
"REST",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = InvocationProtocol;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"INVOCATION_PROTOCOL_UNSPECIFIED" => Ok(InvocationProtocol::Unspecified),
"MCP" => Ok(InvocationProtocol::Mcp),
"A2A" => Ok(InvocationProtocol::A2a),
"OPENAI" => Ok(InvocationProtocol::Openai),
"ANTHROPIC" => Ok(InvocationProtocol::Anthropic),
"REST" => Ok(InvocationProtocol::Rest),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for ListAgentsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.catalog_name.is_empty() {
len += 1;
}
if !self.schema_name.is_empty() {
len += 1;
}
if self.max_results.is_some() {
len += 1;
}
if self.page_token.is_some() {
len += 1;
}
if self.include_browse.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.ListAgentsRequest", len)?;
if !self.catalog_name.is_empty() {
struct_ser.serialize_field("catalog_name", &self.catalog_name)?;
}
if !self.schema_name.is_empty() {
struct_ser.serialize_field("schema_name", &self.schema_name)?;
}
if let Some(v) = self.max_results.as_ref() {
struct_ser.serialize_field("max_results", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if let Some(v) = self.include_browse.as_ref() {
struct_ser.serialize_field("include_browse", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListAgentsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"catalog_name",
"catalogName",
"schema_name",
"schemaName",
"max_results",
"maxResults",
"page_token",
"pageToken",
"include_browse",
"includeBrowse",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CatalogName,
SchemaName,
MaxResults,
PageToken,
IncludeBrowse,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
"schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
"maxResults" | "max_results" => Ok(GeneratedField::MaxResults),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"includeBrowse" | "include_browse" => Ok(GeneratedField::IncludeBrowse),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListAgentsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.ListAgentsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAgentsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut catalog_name__ = None;
let mut schema_name__ = None;
let mut max_results__ = None;
let mut page_token__ = None;
let mut include_browse__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CatalogName => {
if catalog_name__.is_some() {
return Err(serde::de::Error::duplicate_field("catalogName"));
}
catalog_name__ = Some(map_.next_value()?);
}
GeneratedField::SchemaName => {
if schema_name__.is_some() {
return Err(serde::de::Error::duplicate_field("schemaName"));
}
schema_name__ = Some(map_.next_value()?);
}
GeneratedField::MaxResults => {
if max_results__.is_some() {
return Err(serde::de::Error::duplicate_field("maxResults"));
}
max_results__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::IncludeBrowse => {
if include_browse__.is_some() {
return Err(serde::de::Error::duplicate_field("includeBrowse"));
}
include_browse__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListAgentsRequest {
catalog_name: catalog_name__.unwrap_or_default(),
schema_name: schema_name__.unwrap_or_default(),
max_results: max_results__,
page_token: page_token__,
include_browse: include_browse__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.ListAgentsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListAgentsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.agents.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.ListAgentsResponse", len)?;
if !self.agents.is_empty() {
struct_ser.serialize_field("agents", &self.agents)?;
}
if let Some(v) = self.next_page_token.as_ref() {
struct_ser.serialize_field("next_page_token", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListAgentsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"agents",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Agents,
NextPageToken,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"agents" => Ok(GeneratedField::Agents),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListAgentsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.ListAgentsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAgentsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut agents__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Agents => {
if agents__.is_some() {
return Err(serde::de::Error::duplicate_field("agents"));
}
agents__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListAgentsResponse {
agents: agents__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.ListAgentsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateAgentRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if self.new_name.is_some() {
len += 1;
}
if self.invocation_protocol.is_some() {
len += 1;
}
if self.endpoint.is_some() {
len += 1;
}
if self.description.is_some() {
len += 1;
}
if !self.capabilities.is_empty() {
len += 1;
}
if self.input_schema.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.agents.v0alpha1.UpdateAgentRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.new_name.as_ref() {
struct_ser.serialize_field("new_name", v)?;
}
if let Some(v) = self.invocation_protocol.as_ref() {
let v = InvocationProtocol::try_from(*v)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
struct_ser.serialize_field("invocation_protocol", &v)?;
}
if let Some(v) = self.endpoint.as_ref() {
struct_ser.serialize_field("endpoint", v)?;
}
if let Some(v) = self.description.as_ref() {
struct_ser.serialize_field("description", v)?;
}
if !self.capabilities.is_empty() {
struct_ser.serialize_field("capabilities", &self.capabilities)?;
}
if let Some(v) = self.input_schema.as_ref() {
struct_ser.serialize_field("input_schema", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.owner.as_ref() {
struct_ser.serialize_field("owner", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateAgentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"new_name",
"newName",
"invocation_protocol",
"invocationProtocol",
"endpoint",
"description",
"capabilities",
"input_schema",
"inputSchema",
"comment",
"owner",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
NewName,
InvocationProtocol,
Endpoint,
Description,
Capabilities,
InputSchema,
Comment,
Owner,
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"newName" | "new_name" => Ok(GeneratedField::NewName),
"invocationProtocol" | "invocation_protocol" => Ok(GeneratedField::InvocationProtocol),
"endpoint" => Ok(GeneratedField::Endpoint),
"description" => Ok(GeneratedField::Description),
"capabilities" => Ok(GeneratedField::Capabilities),
"inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
"comment" => Ok(GeneratedField::Comment),
"owner" => Ok(GeneratedField::Owner),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateAgentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.agents.v0alpha1.UpdateAgentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateAgentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut new_name__ = None;
let mut invocation_protocol__ = None;
let mut endpoint__ = None;
let mut description__ = None;
let mut capabilities__ = None;
let mut input_schema__ = None;
let mut comment__ = None;
let mut owner__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::NewName => {
if new_name__.is_some() {
return Err(serde::de::Error::duplicate_field("newName"));
}
new_name__ = map_.next_value()?;
}
GeneratedField::InvocationProtocol => {
if invocation_protocol__.is_some() {
return Err(serde::de::Error::duplicate_field("invocationProtocol"));
}
invocation_protocol__ = map_.next_value::<::std::option::Option<InvocationProtocol>>()?.map(|x| x as i32);
}
GeneratedField::Endpoint => {
if endpoint__.is_some() {
return Err(serde::de::Error::duplicate_field("endpoint"));
}
endpoint__ = map_.next_value()?;
}
GeneratedField::Description => {
if description__.is_some() {
return Err(serde::de::Error::duplicate_field("description"));
}
description__ = map_.next_value()?;
}
GeneratedField::Capabilities => {
if capabilities__.is_some() {
return Err(serde::de::Error::duplicate_field("capabilities"));
}
capabilities__ = Some(map_.next_value()?);
}
GeneratedField::InputSchema => {
if input_schema__.is_some() {
return Err(serde::de::Error::duplicate_field("inputSchema"));
}
input_schema__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::Owner => {
if owner__.is_some() {
return Err(serde::de::Error::duplicate_field("owner"));
}
owner__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateAgentRequest {
name: name__.unwrap_or_default(),
new_name: new_name__,
invocation_protocol: invocation_protocol__,
endpoint: endpoint__,
description: description__,
capabilities: capabilities__.unwrap_or_default(),
input_schema: input_schema__,
comment: comment__,
owner: owner__,
})
}
}
deserializer.deserialize_struct("unitycatalog.agents.v0alpha1.UpdateAgentRequest", FIELDS, GeneratedVisitor)
}
}