gproxy-protocol 3.0.0-alpha.0

GPROXY v3 protocol model: operation taxonomy, wire kinds, and the OperationSpec registry
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use serde::{Deserialize, Serialize};

use super::super::{EmbedContentRequest, EmbedContentResponse, JsonMap, Status};
use super::{BatchOperation, BatchResourceFields};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct AsyncBatchEmbedContentRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch: Option<EmbedContentBatch>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

pub type AsyncBatchEmbedContentResponse = BatchOperation;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct UpdateEmbedContentBatchQuery {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub update_mask: Option<String>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct EmbedContentBatch {
    #[serde(flatten)]
    pub resource: BatchResourceFields,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input_config: Option<EmbedContentInputConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output: Option<EmbedContentBatchOutput>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct EmbedContentInputConfig {
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub source: Option<EmbedContentInputSource>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub enum EmbedContentInputSource {
    File {
        #[serde(rename = "fileName")]
        file_name: String,
    },
    Requests {
        requests: InlinedEmbedRequests,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct InlinedEmbedRequests {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub requests: Vec<InlinedEmbedRequest>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(
    Debug, Clone, PartialEq, Serialize, Deserialize, Default, gproxy_protocol_macros::WireBuilder,
)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct InlinedEmbedRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub request: Option<EmbedContentRequest>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<JsonMap>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct EmbedContentBatchOutput {
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub output: Option<EmbedContentBatchOutputData>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub enum EmbedContentBatchOutputData {
    ResponsesFile {
        #[serde(rename = "responsesFile")]
        responses_file: String,
    },
    InlinedResponses {
        #[serde(rename = "inlinedResponses")]
        inlined_responses: InlinedEmbedResponses,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
#[derive(gproxy_protocol_macros::WireBuilder)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct InlinedEmbedResponses {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub inlined_responses: Vec<InlinedEmbedResponse>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(
    Debug, Clone, PartialEq, Serialize, Deserialize, Default, gproxy_protocol_macros::WireBuilder,
)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub struct InlinedEmbedResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<JsonMap>,
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub output: Option<InlinedEmbedResponseOutput>,
    #[serde(default, flatten, skip_serializing_if = "JsonMap::is_empty")]
    pub rest: JsonMap,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
pub enum InlinedEmbedResponseOutput {
    Error { error: Status },
    Response { response: EmbedContentResponse },
}

pub type AsyncBatchEmbedContentRequestBody = AsyncBatchEmbedContentRequest;
pub type AsyncBatchEmbedContentResponseBody = AsyncBatchEmbedContentResponse;
pub type UpdateEmbedContentBatchRequestBody = EmbedContentBatch;
pub type UpdateEmbedContentBatchResponseBody = EmbedContentBatch;
pub type InputEmbedContentConfig = EmbedContentInputConfig;
pub type InputEmbedContentConfigSource = EmbedContentInputSource;
pub type InlinedEmbedContentRequests = InlinedEmbedRequests;
pub type InlinedEmbedContentRequest = InlinedEmbedRequest;
pub type InlinedEmbedContentResponses = InlinedEmbedResponses;
pub type InlinedEmbedContentResponse = InlinedEmbedResponse;
pub type InlinedEmbedContentResponseOutput = InlinedEmbedResponseOutput;