#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct AskEntitiesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub question: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub spaces: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validTime"
)]
pub valid_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct AskEntitiesResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub answer: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub citations: Vec<Citation>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub context: Option<ContextPack>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Citation {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub episode: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub space: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub snippet: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub score: f64,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "occurTime"
)]
pub occur_time: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub sources: Vec<ClaimSource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub claims: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ClaimSource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<SourceRef>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "currentVersion"
)]
pub current_version: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub freshness: Option<ClaimFreshness>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "rereadRequired"
)]
pub reread_required: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CloseRelationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validEndTime"
)]
pub valid_end_time: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ContextPack {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entities: Vec<Entity>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub facts: Vec<Relation>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub citations: Vec<Citation>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "semanticUnavailable"
)]
pub semantic_unavailable: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "entityId"
)]
pub entity_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub entity: Option<Entity>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateEpisodeRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "episodeId"
)]
pub episode_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub episode: Option<Episode>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "skipExtraction"
)]
pub skip_extraction: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateKnowledgeSchemaRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "knowledgeSchemaId"
)]
pub knowledge_schema_id: String,
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "knowledgeSchema"
)]
pub knowledge_schema: Option<KnowledgeSchema>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateRelationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "relationId"
)]
pub relation_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub relation: Option<Relation>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateSpaceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "spaceId"
)]
pub space_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub space: Option<Space>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub force: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteEpisodeRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteKnowledgeSchemaRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteRelationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteSpaceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub force: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Entity {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "entityType"
)]
pub entity_type: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub title: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub aliases: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "externalIds")]
pub external_ids: Vec<ExternalId>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub space: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provenance: Option<Provenance>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<EntityLifecycle>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub survivor: String,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "mergedEntities"
)]
pub merged_entities: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateTime"
)]
pub update_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EntityTypeDefinition {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "typeId"
)]
pub type_id: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "propertiesSchema"
)]
pub properties_schema: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "matchKinds")]
pub match_kinds: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Episode {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<EpisodeKind>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "occurTime"
)]
pub occur_time: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provenance: Option<Provenance>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entities: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extraction: Option<Extraction>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ExternalId {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub kind: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub value: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetEpisodeRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetKnowledgeSchemaRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetRelationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetSpaceRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KnowledgeSchema {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<KnowledgeSchemaSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<KnowledgeSchemaStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KnowledgeSchemaSpec {
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "entityTypes")]
pub entity_types: Vec<EntityTypeDefinition>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "relationTypes"
)]
pub relation_types: Vec<RelationTypeDefinition>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KnowledgeSchemaStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64"
)]
pub revision: i64,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListEntitiesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListEntitiesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entities: Vec<Entity>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListEpisodesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListEpisodesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub episodes: Vec<Episode>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKnowledgeSchemasRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKnowledgeSchemasResponse {
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "knowledgeSchemas"
)]
pub knowledge_schemas: Vec<KnowledgeSchema>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListRelationsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validTime"
)]
pub valid_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "showSuperseded"
)]
pub show_superseded: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListRelationsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub relations: Vec<Relation>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListSpacesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListSpacesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub spaces: Vec<Space>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct MergeEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entities: Vec<String>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub reason: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ProfileEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validTime"
)]
pub valid_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "maxEpisodes"
)]
pub max_episodes: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ProfileEntityResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub entity: Option<Entity>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub facts: Vec<Relation>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "relatedEntities"
)]
pub related_entities: Vec<Entity>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "recentEpisodes"
)]
pub recent_episodes: Vec<Citation>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Provenance {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub principal: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub actor: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub channel: Option<Channel>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub method: Option<SourceMethod>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub references: Vec<SourceRef>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub model: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub confidence: f64,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RecallEntitiesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub query: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub spaces: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "entityTypes")]
pub entity_types: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validTime"
)]
pub valid_time: String,
#[serde(default, skip_serializing_if = "Option::is_none", alias = "maxHops")]
pub max_hops: Option<i32>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "maxFacts"
)]
pub max_facts: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RecallEntitiesResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub context: Option<ContextPack>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Relation {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub subject: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub predicate: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub object: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub value: serde_json::Value,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub statement: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validStartTime"
)]
pub valid_start_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validEndTime"
)]
pub valid_end_time: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub episodes: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provenance: Option<Provenance>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub successor: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "supersedeTime"
)]
pub supersede_time: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub sources: Vec<ClaimSource>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RelationTypeDefinition {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub predicate: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "subjectTypes")]
pub subject_types: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "objectTypes")]
pub object_types: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SourceRef {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uri: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub label: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pinnedVersion"
)]
pub pinned_version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Space {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<SpaceSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<SpaceStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SpaceGrant {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub role: Option<SpaceRole>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub subject: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SpaceSpec {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<SpaceKind>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub owner: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub grants: Vec<SpaceGrant>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub sensitive: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub schemas: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SpaceStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "episodeCount"
)]
pub episode_count: i64,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "factCount"
)]
pub fact_count: i64,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "lastWriteTime"
)]
pub last_write_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SplitEntityRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub entity: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SplitEntityResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub survivor: Option<Entity>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub restored: Option<Entity>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateEntityRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub entity: Option<Entity>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateKnowledgeSchemaRequest {
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "knowledgeSchema"
)]
pub knowledge_schema: Option<KnowledgeSchema>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateSpaceRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub space: Option<Space>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Channel {
Api,
Tool,
Import,
Extraction,
Unknown(String),
}
impl Channel {
pub fn as_str(&self) -> &str {
match self {
Self::Api => "api",
Self::Tool => "tool",
Self::Import => "import",
Self::Extraction => "extraction",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"api" => Self::Api,
"tool" => Self::Tool,
"import" => Self::Import,
"extraction" => Self::Extraction,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for Channel {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for Channel {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for Channel {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ClaimFreshness {
Current,
Stale,
Unknown(String),
}
impl ClaimFreshness {
pub fn as_str(&self) -> &str {
match self {
Self::Current => "current",
Self::Stale => "stale",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"current" => Self::Current,
"stale" => Self::Stale,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ClaimFreshness {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for ClaimFreshness {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for ClaimFreshness {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EntityLifecycle {
Active,
Merged,
Unknown(String),
}
impl EntityLifecycle {
pub fn as_str(&self) -> &str {
match self {
Self::Active => "active",
Self::Merged => "merged",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"active" => Self::Active,
"merged" => Self::Merged,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for EntityLifecycle {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for EntityLifecycle {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for EntityLifecycle {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EpisodeKind {
Note,
Message,
StepResult,
DocumentChunk,
ImportedRow,
Structured,
Unknown(String),
}
impl EpisodeKind {
pub fn as_str(&self) -> &str {
match self {
Self::Note => "note",
Self::Message => "message",
Self::StepResult => "step_result",
Self::DocumentChunk => "document_chunk",
Self::ImportedRow => "imported_row",
Self::Structured => "structured",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"note" => Self::Note,
"message" => Self::Message,
"step_result" => Self::StepResult,
"document_chunk" => Self::DocumentChunk,
"imported_row" => Self::ImportedRow,
"structured" => Self::Structured,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for EpisodeKind {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for EpisodeKind {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for EpisodeKind {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Extraction {
Pending,
Done,
Failed,
Skipped,
Unknown(String),
}
impl Extraction {
pub fn as_str(&self) -> &str {
match self {
Self::Pending => "pending",
Self::Done => "done",
Self::Failed => "failed",
Self::Skipped => "skipped",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"pending" => Self::Pending,
"done" => Self::Done,
"failed" => Self::Failed,
"skipped" => Self::Skipped,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for Extraction {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for Extraction {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for Extraction {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SourceMethod {
Stated,
Extracted,
Imported,
Unknown(String),
}
impl SourceMethod {
pub fn as_str(&self) -> &str {
match self {
Self::Stated => "stated",
Self::Extracted => "extracted",
Self::Imported => "imported",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"stated" => Self::Stated,
"extracted" => Self::Extracted,
"imported" => Self::Imported,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for SourceMethod {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SourceMethod {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for SourceMethod {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SpaceKind {
Workspace,
Project,
Team,
EndUser,
Agent,
Shared,
Unknown(String),
}
impl SpaceKind {
pub fn as_str(&self) -> &str {
match self {
Self::Workspace => "workspace",
Self::Project => "project",
Self::Team => "team",
Self::EndUser => "end_user",
Self::Agent => "agent",
Self::Shared => "shared",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"workspace" => Self::Workspace,
"project" => Self::Project,
"team" => Self::Team,
"end_user" => Self::EndUser,
"agent" => Self::Agent,
"shared" => Self::Shared,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for SpaceKind {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SpaceKind {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for SpaceKind {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SpaceRole {
Reader,
Writer,
Owner,
Unknown(String),
}
impl SpaceRole {
pub fn as_str(&self) -> &str {
match self {
Self::Reader => "reader",
Self::Writer => "writer",
Self::Owner => "owner",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"reader" => Self::Reader,
"writer" => Self::Writer,
"owner" => Self::Owner,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for SpaceRole {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for SpaceRole {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for SpaceRole {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn knowledge(&self) -> KnowledgeApi<'_, T> {
KnowledgeApi { client: self }
}
}
pub struct KnowledgeApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> KnowledgeApi<'a, T> {
pub async fn remember(
&self,
request: CreateEpisodeRequest,
) -> Result<Episode, crate::runtime::Error> {
let path = format!(
"/v1/{}/episodes",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("episode_id", &request.episode_id);
query.push("validate_only", &request.validate_only);
query.push("skip_extraction", &request.skip_extraction);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.episode)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn entity(
&self,
request: ProfileEntityRequest,
) -> Result<ProfileEntityResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:profile",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn recall(
&self,
request: RecallEntitiesRequest,
) -> Result<RecallEntitiesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities:recall",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["parent"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn ask(
&self,
request: AskEntitiesRequest,
) -> Result<AskEntitiesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities:ask",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["parent"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn relate(
&self,
request: CreateRelationRequest,
) -> Result<Relation, crate::runtime::Error> {
let path = format!(
"/v1/{}/relations",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("relation_id", &request.relation_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.relation)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn close_fact(
&self,
request: CloseRelationRequest,
) -> Result<Relation, crate::runtime::Error> {
let path = format!(
"/v1/{}:close",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/relations/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub fn spaces(&self) -> SpacesCollection<'a, T> {
SpacesCollection {
client: self.client,
}
}
pub fn knowledge_schemas(&self) -> KnowledgeSchemasCollection<'a, T> {
KnowledgeSchemasCollection {
client: self.client,
}
}
pub fn episodes(&self) -> EpisodesCollection<'a, T> {
EpisodesCollection {
client: self.client,
}
}
pub fn entities(&self) -> EntitiesCollection<'a, T> {
EntitiesCollection {
client: self.client,
}
}
pub fn relations(&self) -> RelationsCollection<'a, T> {
RelationsCollection {
client: self.client,
}
}
}
pub struct SpacesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> SpacesCollection<'a, T> {
pub async fn get(&self, request: GetSpaceRequest) -> Result<Space, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/spaces/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListSpacesRequest,
) -> Result<ListSpacesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/spaces",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListSpacesRequest,
) -> Result<Vec<Space>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.spaces);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateSpaceRequest,
) -> Result<Space, crate::runtime::Error> {
let path = format!(
"/v1/{}/spaces",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("space_id", &request.space_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.space)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn update(
&self,
request: UpdateSpaceRequest,
) -> Result<Space, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.space
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/spaces/*",
"space.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.space)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteSpaceRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/spaces/*", "name")?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
query.push("force", &request.force);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct KnowledgeSchemasCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> KnowledgeSchemasCollection<'a, T> {
pub async fn get(
&self,
request: GetKnowledgeSchemaRequest,
) -> Result<KnowledgeSchema, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/knowledge_schemas/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListKnowledgeSchemasRequest,
) -> Result<ListKnowledgeSchemasResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/knowledge_schemas",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListKnowledgeSchemasRequest,
) -> Result<Vec<KnowledgeSchema>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.knowledge_schemas);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateKnowledgeSchemaRequest,
) -> Result<KnowledgeSchema, crate::runtime::Error> {
let path = format!(
"/v1/{}/knowledge_schemas",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("knowledge_schema_id", &request.knowledge_schema_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.knowledge_schema)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn update(
&self,
request: UpdateKnowledgeSchemaRequest,
) -> Result<KnowledgeSchema, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.knowledge_schema
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/knowledge_schemas/*",
"knowledge_schema.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.knowledge_schema)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteKnowledgeSchemaRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/knowledge_schemas/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct EpisodesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> EpisodesCollection<'a, T> {
pub async fn get(&self, request: GetEpisodeRequest) -> Result<Episode, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/episodes/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListEpisodesRequest,
) -> Result<ListEpisodesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/episodes",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListEpisodesRequest,
) -> Result<Vec<Episode>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.episodes);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateEpisodeRequest,
) -> Result<Episode, crate::runtime::Error> {
let path = format!(
"/v1/{}/episodes",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("episode_id", &request.episode_id);
query.push("validate_only", &request.validate_only);
query.push("skip_extraction", &request.skip_extraction);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.episode)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteEpisodeRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/episodes/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct EntitiesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> EntitiesCollection<'a, T> {
pub async fn get(&self, request: GetEntityRequest) -> Result<Entity, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListEntitiesRequest,
) -> Result<ListEntitiesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListEntitiesRequest,
) -> Result<Vec<Entity>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.entities);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateEntityRequest,
) -> Result<Entity, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("entity_id", &request.entity_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.entity)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn update(
&self,
request: UpdateEntityRequest,
) -> Result<Entity, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.entity
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/entities/*",
"entity.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.entity)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteEntityRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
query.push("force", &request.force);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn merge(
&self,
request: MergeEntityRequest,
) -> Result<Entity, crate::runtime::Error> {
let path = format!(
"/v1/{}:merge",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn split(
&self,
request: SplitEntityRequest,
) -> Result<SplitEntityResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:split",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn profile(
&self,
request: ProfileEntityRequest,
) -> Result<ProfileEntityResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:profile",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/entities/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn recall(
&self,
request: RecallEntitiesRequest,
) -> Result<RecallEntitiesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities:recall",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["parent"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn ask(
&self,
request: AskEntitiesRequest,
) -> Result<AskEntitiesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entities:ask",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["parent"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct RelationsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> RelationsCollection<'a, T> {
pub async fn get(
&self,
request: GetRelationRequest,
) -> Result<Relation, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/relations/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListRelationsRequest,
) -> Result<ListRelationsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/relations",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("valid_time", &request.valid_time);
query.push("show_superseded", &request.show_superseded);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListRelationsRequest,
) -> Result<Vec<Relation>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.relations);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateRelationRequest,
) -> Result<Relation, crate::runtime::Error> {
let path = format!(
"/v1/{}/relations",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/spaces/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("relation_id", &request.relation_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.relation)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteRelationRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/relations/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn close(
&self,
request: CloseRelationRequest,
) -> Result<Relation, crate::runtime::Error> {
let path = format!(
"/v1/{}:close",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/spaces/*/relations/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}