nominal_api_proto/proto/
nominal.internalcodesandbox.v1.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct PythonExecution {
4    #[prost(string, tag = "1")]
5    pub code: ::prost::alloc::string::String,
6}
7#[derive(Clone, PartialEq, ::prost::Message)]
8pub struct ShellExecution {
9    #[prost(string, optional, tag = "3")]
10    pub cwd: ::core::option::Option<::prost::alloc::string::String>,
11    #[prost(bool, tag = "4")]
12    pub interactive: bool,
13    #[prost(oneof = "shell_execution::Invocation", tags = "1, 2")]
14    pub invocation: ::core::option::Option<shell_execution::Invocation>,
15}
16/// Nested message and enum types in `ShellExecution`.
17pub mod shell_execution {
18    #[derive(Clone, PartialEq, ::prost::Oneof)]
19    pub enum Invocation {
20        #[prost(string, tag = "1")]
21        Command(::prost::alloc::string::String),
22        #[prost(message, tag = "2")]
23        Arguments(super::ShellArguments),
24    }
25}
26#[derive(Clone, PartialEq, ::prost::Message)]
27pub struct ShellArguments {
28    #[prost(string, repeated, tag = "1")]
29    pub argv: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
30}
31#[derive(Clone, PartialEq, ::prost::Message)]
32pub struct ExecutionIntent {
33    #[prost(string, tag = "1")]
34    pub execution_id: ::prost::alloc::string::String,
35    #[prost(string, tag = "2")]
36    pub run_id: ::prost::alloc::string::String,
37    #[prost(uint32, tag = "5")]
38    pub timeout_ms: u32,
39    #[prost(oneof = "execution_intent::Execution", tags = "3, 4")]
40    pub execution: ::core::option::Option<execution_intent::Execution>,
41}
42/// Nested message and enum types in `ExecutionIntent`.
43pub mod execution_intent {
44    #[derive(Clone, PartialEq, ::prost::Oneof)]
45    pub enum Execution {
46        #[prost(message, tag = "3")]
47        Python(super::PythonExecution),
48        #[prost(message, tag = "4")]
49        Shell(super::ShellExecution),
50    }
51}
52#[derive(Clone, PartialEq, ::prost::Message)]
53pub struct ExecutionArtifact {
54    #[prost(string, tag = "1")]
55    pub path: ::prost::alloc::string::String,
56    #[prost(string, tag = "2")]
57    pub media_type: ::prost::alloc::string::String,
58}
59#[derive(Clone, PartialEq, ::prost::Message)]
60pub struct ExecutionOutput {
61    #[prost(oneof = "execution_output::Output", tags = "1, 2, 3, 4")]
62    pub output: ::core::option::Option<execution_output::Output>,
63}
64/// Nested message and enum types in `ExecutionOutput`.
65pub mod execution_output {
66    #[derive(Clone, PartialEq, ::prost::Message)]
67    pub struct Stream {
68        #[prost(enumeration = "StreamName", tag = "1")]
69        pub name: i32,
70        #[prost(string, tag = "2")]
71        pub text: ::prost::alloc::string::String,
72    }
73    #[derive(Clone, PartialEq, ::prost::Message)]
74    pub struct Result {
75        #[prost(string, tag = "1")]
76        pub text_plain: ::prost::alloc::string::String,
77    }
78    #[derive(Clone, PartialEq, ::prost::Message)]
79    pub struct Display {
80        #[prost(string, tag = "1")]
81        pub text_plain: ::prost::alloc::string::String,
82        #[prost(uint32, optional, tag = "2")]
83        pub artifact_index: ::core::option::Option<u32>,
84    }
85    #[derive(Clone, PartialEq, ::prost::Message)]
86    pub struct Error {
87        #[prost(string, tag = "1")]
88        pub ename: ::prost::alloc::string::String,
89        #[prost(string, tag = "2")]
90        pub evalue: ::prost::alloc::string::String,
91        #[prost(string, repeated, tag = "3")]
92        pub traceback: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
93    }
94    #[derive(
95        Clone,
96        Copy,
97        Debug,
98        PartialEq,
99        Eq,
100        Hash,
101        PartialOrd,
102        Ord,
103        ::prost::Enumeration
104    )]
105    #[repr(i32)]
106    pub enum StreamName {
107        Unspecified = 0,
108        Stdout = 1,
109        Stderr = 2,
110    }
111    impl StreamName {
112        /// String value of the enum field names used in the ProtoBuf definition.
113        ///
114        /// The values are not transformed in any way and thus are considered stable
115        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
116        pub fn as_str_name(&self) -> &'static str {
117            match self {
118                Self::Unspecified => "STREAM_NAME_UNSPECIFIED",
119                Self::Stdout => "STREAM_NAME_STDOUT",
120                Self::Stderr => "STREAM_NAME_STDERR",
121            }
122        }
123        /// Creates an enum from field names used in the ProtoBuf definition.
124        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
125            match value {
126                "STREAM_NAME_UNSPECIFIED" => Some(Self::Unspecified),
127                "STREAM_NAME_STDOUT" => Some(Self::Stdout),
128                "STREAM_NAME_STDERR" => Some(Self::Stderr),
129                _ => None,
130            }
131        }
132    }
133    #[derive(Clone, PartialEq, ::prost::Oneof)]
134    pub enum Output {
135        #[prost(message, tag = "1")]
136        Stream(Stream),
137        #[prost(message, tag = "2")]
138        Result(Result),
139        #[prost(message, tag = "3")]
140        Display(Display),
141        #[prost(message, tag = "4")]
142        Error(Error),
143    }
144}
145#[derive(Clone, PartialEq, ::prost::Message)]
146pub struct ExecutionSnapshot {
147    #[prost(string, tag = "1")]
148    pub execution_id: ::prost::alloc::string::String,
149    #[prost(enumeration = "ExecutionKind", tag = "2")]
150    pub kind: i32,
151    #[prost(enumeration = "ExecutionState", tag = "3")]
152    pub state: i32,
153    #[prost(bytes = "vec", tag = "4")]
154    pub output: ::prost::alloc::vec::Vec<u8>,
155    #[prost(uint64, tag = "5")]
156    pub offset: u64,
157    #[prost(uint64, tag = "6")]
158    pub next_offset: u64,
159    #[prost(uint64, tag = "7")]
160    pub output_size: u64,
161    #[prost(bool, tag = "8")]
162    pub has_more: bool,
163    #[prost(int32, optional, tag = "9")]
164    pub exit_code: ::core::option::Option<i32>,
165    #[prost(bool, tag = "11")]
166    pub truncated: bool,
167    #[prost(message, repeated, tag = "12")]
168    pub artifacts: ::prost::alloc::vec::Vec<ExecutionArtifact>,
169    #[prost(string, tag = "13")]
170    pub output_path: ::prost::alloc::string::String,
171    #[prost(string, tag = "14")]
172    pub notice: ::prost::alloc::string::String,
173    #[prost(message, repeated, tag = "15")]
174    pub outputs: ::prost::alloc::vec::Vec<ExecutionOutput>,
175    #[prost(bool, tag = "16")]
176    pub outputs_truncated: bool,
177}
178#[derive(Clone, PartialEq, ::prost::Message)]
179pub struct StartExecutionOperation {
180    #[prost(message, optional, tag = "1")]
181    pub intent: ::core::option::Option<ExecutionIntent>,
182    #[prost(uint32, optional, tag = "2")]
183    pub wait_ms: ::core::option::Option<u32>,
184}
185#[derive(Clone, PartialEq, ::prost::Message)]
186pub struct ReadExecutionOperation {
187    #[prost(string, tag = "1")]
188    pub execution_id: ::prost::alloc::string::String,
189    #[prost(uint64, tag = "2")]
190    pub offset: u64,
191    #[prost(uint32, optional, tag = "3")]
192    pub wait_ms: ::core::option::Option<u32>,
193    #[prost(uint32, optional, tag = "4")]
194    pub max_output_bytes: ::core::option::Option<u32>,
195}
196#[derive(Clone, PartialEq, ::prost::Message)]
197pub struct WriteStdinOperation {
198    #[prost(string, tag = "1")]
199    pub execution_id: ::prost::alloc::string::String,
200    #[prost(string, tag = "2")]
201    pub operation_id: ::prost::alloc::string::String,
202    #[prost(bytes = "vec", tag = "3")]
203    pub input: ::prost::alloc::vec::Vec<u8>,
204    #[prost(bool, tag = "4")]
205    pub close_stdin: bool,
206}
207#[derive(Clone, PartialEq, ::prost::Message)]
208pub struct KillExecutionOperation {
209    #[prost(string, tag = "1")]
210    pub execution_id: ::prost::alloc::string::String,
211}
212#[derive(Clone, PartialEq, ::prost::Message)]
213pub struct GetExecutionStatusesOperation {
214    #[prost(string, repeated, tag = "1")]
215    pub execution_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
216}
217#[derive(Clone, PartialEq, ::prost::Message)]
218pub struct ExecutionStatus {
219    #[prost(string, tag = "1")]
220    pub execution_id: ::prost::alloc::string::String,
221    #[prost(enumeration = "ExecutionKind", tag = "2")]
222    pub kind: i32,
223    #[prost(enumeration = "ExecutionState", tag = "3")]
224    pub state: i32,
225    #[prost(uint64, tag = "4")]
226    pub output_size: u64,
227    #[prost(int32, optional, tag = "5")]
228    pub exit_code: ::core::option::Option<i32>,
229    #[prost(bool, tag = "7")]
230    pub truncated: bool,
231    #[prost(string, tag = "8")]
232    pub notice: ::prost::alloc::string::String,
233}
234#[derive(Clone, PartialEq, ::prost::Message)]
235pub struct ExecutionStatuses {
236    #[prost(message, repeated, tag = "1")]
237    pub statuses: ::prost::alloc::vec::Vec<ExecutionStatus>,
238}
239#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
240#[repr(i32)]
241pub enum ExecutionKind {
242    Unspecified = 0,
243    Python = 1,
244    Shell = 2,
245}
246impl ExecutionKind {
247    /// String value of the enum field names used in the ProtoBuf definition.
248    ///
249    /// The values are not transformed in any way and thus are considered stable
250    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
251    pub fn as_str_name(&self) -> &'static str {
252        match self {
253            Self::Unspecified => "EXECUTION_KIND_UNSPECIFIED",
254            Self::Python => "EXECUTION_KIND_PYTHON",
255            Self::Shell => "EXECUTION_KIND_SHELL",
256        }
257    }
258    /// Creates an enum from field names used in the ProtoBuf definition.
259    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
260        match value {
261            "EXECUTION_KIND_UNSPECIFIED" => Some(Self::Unspecified),
262            "EXECUTION_KIND_PYTHON" => Some(Self::Python),
263            "EXECUTION_KIND_SHELL" => Some(Self::Shell),
264            _ => None,
265        }
266    }
267}
268#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
269#[repr(i32)]
270pub enum ExecutionState {
271    Unspecified = 0,
272    Running = 1,
273    Exited = 2,
274    Killed = 3,
275    Unknown = 4,
276    TimedOut = 5,
277}
278impl ExecutionState {
279    /// String value of the enum field names used in the ProtoBuf definition.
280    ///
281    /// The values are not transformed in any way and thus are considered stable
282    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
283    pub fn as_str_name(&self) -> &'static str {
284        match self {
285            Self::Unspecified => "EXECUTION_STATE_UNSPECIFIED",
286            Self::Running => "EXECUTION_STATE_RUNNING",
287            Self::Exited => "EXECUTION_STATE_EXITED",
288            Self::Killed => "EXECUTION_STATE_KILLED",
289            Self::Unknown => "EXECUTION_STATE_UNKNOWN",
290            Self::TimedOut => "EXECUTION_STATE_TIMED_OUT",
291        }
292    }
293    /// Creates an enum from field names used in the ProtoBuf definition.
294    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
295        match value {
296            "EXECUTION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
297            "EXECUTION_STATE_RUNNING" => Some(Self::Running),
298            "EXECUTION_STATE_EXITED" => Some(Self::Exited),
299            "EXECUTION_STATE_KILLED" => Some(Self::Killed),
300            "EXECUTION_STATE_UNKNOWN" => Some(Self::Unknown),
301            "EXECUTION_STATE_TIMED_OUT" => Some(Self::TimedOut),
302            _ => None,
303        }
304    }
305}
306#[derive(Clone, PartialEq, ::prost::Message)]
307pub struct WorkspacePath {
308    #[prost(string, tag = "1")]
309    pub path: ::prost::alloc::string::String,
310}
311#[derive(Clone, PartialEq, ::prost::Message)]
312pub struct WorkspaceFileEntry {
313    #[prost(string, tag = "1")]
314    pub path: ::prost::alloc::string::String,
315    #[prost(string, tag = "2")]
316    pub name: ::prost::alloc::string::String,
317    #[prost(bool, tag = "3")]
318    pub is_directory: bool,
319    #[prost(uint64, tag = "4")]
320    pub size: u64,
321}
322#[derive(Clone, PartialEq, ::prost::Message)]
323pub struct StatFileOperation {
324    #[prost(message, optional, tag = "1")]
325    pub path: ::core::option::Option<WorkspacePath>,
326}
327#[derive(Clone, PartialEq, ::prost::Message)]
328pub struct StatFileResult {
329    #[prost(message, optional, tag = "1")]
330    pub entry: ::core::option::Option<WorkspaceFileEntry>,
331}
332#[derive(Clone, PartialEq, ::prost::Message)]
333pub struct ListFilesOperation {
334    #[prost(message, optional, tag = "1")]
335    pub path: ::core::option::Option<WorkspacePath>,
336    #[prost(uint32, tag = "2")]
337    pub page_size: u32,
338    #[prost(string, tag = "3")]
339    pub page_token: ::prost::alloc::string::String,
340}
341#[derive(Clone, PartialEq, ::prost::Message)]
342pub struct ListFilesResult {
343    #[prost(message, repeated, tag = "1")]
344    pub entries: ::prost::alloc::vec::Vec<WorkspaceFileEntry>,
345    #[prost(string, tag = "2")]
346    pub next_page_token: ::prost::alloc::string::String,
347}
348#[derive(Clone, PartialEq, ::prost::Message)]
349pub struct FindFilesOperation {
350    #[prost(message, optional, tag = "1")]
351    pub path: ::core::option::Option<WorkspacePath>,
352    #[prost(string, tag = "2")]
353    pub pattern: ::prost::alloc::string::String,
354    #[prost(uint32, tag = "3")]
355    pub max_results: u32,
356}
357#[derive(Clone, PartialEq, ::prost::Message)]
358pub struct FindFilesResult {
359    #[prost(message, repeated, tag = "1")]
360    pub entries: ::prost::alloc::vec::Vec<WorkspaceFileEntry>,
361    #[prost(bool, tag = "2")]
362    pub truncated: bool,
363}
364#[derive(Clone, PartialEq, ::prost::Message)]
365pub struct GrepFilesOperation {
366    #[prost(message, optional, tag = "1")]
367    pub path: ::core::option::Option<WorkspacePath>,
368    #[prost(string, tag = "2")]
369    pub pattern: ::prost::alloc::string::String,
370    #[prost(bool, tag = "3")]
371    pub regex: bool,
372    #[prost(bool, tag = "4")]
373    pub case_sensitive: bool,
374    #[prost(uint32, tag = "5")]
375    pub max_results: u32,
376}
377#[derive(Clone, PartialEq, ::prost::Message)]
378pub struct WorkspaceGrepMatch {
379    #[prost(string, tag = "1")]
380    pub path: ::prost::alloc::string::String,
381    #[prost(uint64, tag = "2")]
382    pub line_number: u64,
383    #[prost(string, tag = "3")]
384    pub text: ::prost::alloc::string::String,
385}
386#[derive(Clone, PartialEq, ::prost::Message)]
387pub struct GrepFilesResult {
388    #[prost(message, repeated, tag = "1")]
389    pub matches: ::prost::alloc::vec::Vec<WorkspaceGrepMatch>,
390    #[prost(bool, tag = "2")]
391    pub truncated: bool,
392}
393#[derive(Clone, PartialEq, ::prost::Message)]
394pub struct RealpathOperation {
395    #[prost(message, optional, tag = "1")]
396    pub path: ::core::option::Option<WorkspacePath>,
397}
398#[derive(Clone, PartialEq, ::prost::Message)]
399pub struct RealpathResult {
400    #[prost(message, optional, tag = "1")]
401    pub path: ::core::option::Option<WorkspacePath>,
402}
403#[derive(Clone, PartialEq, ::prost::Message)]
404pub struct MkdirOperation {
405    #[prost(message, optional, tag = "1")]
406    pub path: ::core::option::Option<WorkspacePath>,
407    #[prost(bool, tag = "2")]
408    pub parents: bool,
409}
410#[derive(Clone, PartialEq, ::prost::Message)]
411pub struct RemoveFileOperation {
412    #[prost(message, optional, tag = "1")]
413    pub path: ::core::option::Option<WorkspacePath>,
414    #[prost(bool, tag = "2")]
415    pub recursive: bool,
416}
417#[derive(Clone, Copy, PartialEq, ::prost::Message)]
418pub struct FileMutationResult {}
419#[derive(Clone, PartialEq, ::prost::Message)]
420pub struct DownloadFileOperation {
421    #[prost(message, optional, tag = "1")]
422    pub path: ::core::option::Option<WorkspacePath>,
423    #[prost(string, tag = "2")]
424    pub url: ::prost::alloc::string::String,
425    #[prost(uint64, tag = "3")]
426    pub max_bytes: u64,
427    #[prost(uint32, tag = "4")]
428    pub wait_ms: u32,
429}
430#[derive(Clone, PartialEq, ::prost::Message)]
431pub struct DownloadFileResult {
432    #[prost(enumeration = "DownloadState", tag = "1")]
433    pub state: i32,
434    #[prost(uint64, tag = "2")]
435    pub size: u64,
436    #[prost(string, tag = "3")]
437    pub sha256: ::prost::alloc::string::String,
438    #[prost(bytes = "vec", tag = "4")]
439    pub head: ::prost::alloc::vec::Vec<u8>,
440    #[prost(string, tag = "5")]
441    pub reason: ::prost::alloc::string::String,
442}
443#[derive(Clone, PartialEq, ::prost::Message)]
444pub struct UploadFilePartOperation {
445    #[prost(message, optional, tag = "1")]
446    pub path: ::core::option::Option<WorkspacePath>,
447    #[prost(uint64, tag = "2")]
448    pub offset: u64,
449    #[prost(uint64, tag = "3")]
450    pub length: u64,
451    #[prost(string, tag = "4")]
452    pub url: ::prost::alloc::string::String,
453    #[prost(map = "string, string", tag = "5")]
454    pub headers: ::std::collections::HashMap<
455        ::prost::alloc::string::String,
456        ::prost::alloc::string::String,
457    >,
458}
459#[derive(Clone, PartialEq, ::prost::Message)]
460pub struct UploadFilePartResult {
461    #[prost(string, tag = "1")]
462    pub etag: ::prost::alloc::string::String,
463}
464#[derive(Clone, PartialEq, ::prost::Message)]
465pub struct WorkspaceFileOperation {
466    #[prost(
467        oneof = "workspace_file_operation::Operation",
468        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9"
469    )]
470    pub operation: ::core::option::Option<workspace_file_operation::Operation>,
471}
472/// Nested message and enum types in `WorkspaceFileOperation`.
473pub mod workspace_file_operation {
474    #[derive(Clone, PartialEq, ::prost::Oneof)]
475    pub enum Operation {
476        #[prost(message, tag = "1")]
477        Stat(super::StatFileOperation),
478        #[prost(message, tag = "2")]
479        List(super::ListFilesOperation),
480        #[prost(message, tag = "3")]
481        Find(super::FindFilesOperation),
482        #[prost(message, tag = "4")]
483        Grep(super::GrepFilesOperation),
484        #[prost(message, tag = "5")]
485        Realpath(super::RealpathOperation),
486        #[prost(message, tag = "6")]
487        Mkdir(super::MkdirOperation),
488        #[prost(message, tag = "7")]
489        Remove(super::RemoveFileOperation),
490        #[prost(message, tag = "8")]
491        Download(super::DownloadFileOperation),
492        #[prost(message, tag = "9")]
493        UploadPart(super::UploadFilePartOperation),
494    }
495}
496#[derive(Clone, PartialEq, ::prost::Message)]
497pub struct WorkspaceFileResult {
498    #[prost(oneof = "workspace_file_result::Result", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
499    pub result: ::core::option::Option<workspace_file_result::Result>,
500}
501/// Nested message and enum types in `WorkspaceFileResult`.
502pub mod workspace_file_result {
503    #[derive(Clone, PartialEq, ::prost::Oneof)]
504    pub enum Result {
505        #[prost(message, tag = "1")]
506        Stat(super::StatFileResult),
507        #[prost(message, tag = "2")]
508        List(super::ListFilesResult),
509        #[prost(message, tag = "3")]
510        Find(super::FindFilesResult),
511        #[prost(message, tag = "4")]
512        Grep(super::GrepFilesResult),
513        #[prost(message, tag = "5")]
514        Realpath(super::RealpathResult),
515        #[prost(message, tag = "6")]
516        Mkdir(super::FileMutationResult),
517        #[prost(message, tag = "7")]
518        Remove(super::FileMutationResult),
519        #[prost(message, tag = "8")]
520        Download(super::DownloadFileResult),
521        #[prost(message, tag = "9")]
522        UploadPart(super::UploadFilePartResult),
523    }
524}
525#[derive(Clone, PartialEq, ::prost::Message)]
526pub struct ReadFileOperation {
527    #[prost(message, optional, tag = "1")]
528    pub path: ::core::option::Option<WorkspacePath>,
529    #[prost(uint64, tag = "2")]
530    pub offset: u64,
531    #[prost(uint32, optional, tag = "3")]
532    pub max_bytes: ::core::option::Option<u32>,
533}
534#[derive(Clone, PartialEq, ::prost::Message)]
535pub struct FileChunk {
536    #[prost(bytes = "vec", tag = "1")]
537    pub data: ::prost::alloc::vec::Vec<u8>,
538    #[prost(uint64, tag = "2")]
539    pub offset: u64,
540}
541#[derive(Clone, PartialEq, ::prost::Message)]
542pub struct WriteFileOperation {
543    #[prost(message, optional, tag = "1")]
544    pub path: ::core::option::Option<WorkspacePath>,
545    #[prost(message, optional, tag = "2")]
546    pub chunk: ::core::option::Option<FileChunk>,
547}
548#[derive(Clone, Copy, PartialEq, ::prost::Message)]
549pub struct WriteFileResult {
550    #[prost(uint64, tag = "1")]
551    pub written: u64,
552}
553#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
554#[repr(i32)]
555pub enum DownloadState {
556    Unspecified = 0,
557    Loading = 1,
558    Ready = 2,
559    TooLarge = 3,
560    Failed = 4,
561}
562impl DownloadState {
563    /// String value of the enum field names used in the ProtoBuf definition.
564    ///
565    /// The values are not transformed in any way and thus are considered stable
566    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
567    pub fn as_str_name(&self) -> &'static str {
568        match self {
569            Self::Unspecified => "DOWNLOAD_STATE_UNSPECIFIED",
570            Self::Loading => "DOWNLOAD_STATE_LOADING",
571            Self::Ready => "DOWNLOAD_STATE_READY",
572            Self::TooLarge => "DOWNLOAD_STATE_TOO_LARGE",
573            Self::Failed => "DOWNLOAD_STATE_FAILED",
574        }
575    }
576    /// Creates an enum from field names used in the ProtoBuf definition.
577    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
578        match value {
579            "DOWNLOAD_STATE_UNSPECIFIED" => Some(Self::Unspecified),
580            "DOWNLOAD_STATE_LOADING" => Some(Self::Loading),
581            "DOWNLOAD_STATE_READY" => Some(Self::Ready),
582            "DOWNLOAD_STATE_TOO_LARGE" => Some(Self::TooLarge),
583            "DOWNLOAD_STATE_FAILED" => Some(Self::Failed),
584            _ => None,
585        }
586    }
587}
588#[derive(Clone, PartialEq, ::prost::Message)]
589pub struct Sandbox {
590    #[prost(string, tag = "1")]
591    pub sandbox_rid: ::prost::alloc::string::String,
592    #[prost(enumeration = "SandboxStatus", tag = "2")]
593    pub status: i32,
594    #[prost(message, optional, tag = "3")]
595    pub created_at: ::core::option::Option<
596        super::super::super::google::protobuf::Timestamp,
597    >,
598    #[prost(message, optional, tag = "4")]
599    pub last_activity_at: ::core::option::Option<
600        super::super::super::google::protobuf::Timestamp,
601    >,
602    #[prost(uint32, tag = "5")]
603    pub idle_timeout_seconds: u32,
604}
605#[derive(Clone, PartialEq, ::prost::Message)]
606pub struct CreateSandboxRequest {
607    #[prost(string, tag = "1")]
608    pub parent_rid: ::prost::alloc::string::String,
609}
610#[derive(Clone, PartialEq, ::prost::Message)]
611pub struct CreateSandboxResponse {
612    #[prost(message, optional, tag = "1")]
613    pub sandbox: ::core::option::Option<Sandbox>,
614    #[prost(bool, tag = "2")]
615    pub created: bool,
616}
617#[derive(Clone, PartialEq, ::prost::Message)]
618pub struct GetSandboxRequest {
619    #[prost(string, tag = "1")]
620    pub sandbox_rid: ::prost::alloc::string::String,
621}
622#[derive(Clone, PartialEq, ::prost::Message)]
623pub struct GetSandboxResponse {
624    #[prost(message, optional, tag = "1")]
625    pub sandbox: ::core::option::Option<Sandbox>,
626}
627#[derive(Clone, PartialEq, ::prost::Message)]
628pub struct GetLiveSandboxRequest {
629    #[prost(string, tag = "1")]
630    pub parent_rid: ::prost::alloc::string::String,
631}
632#[derive(Clone, PartialEq, ::prost::Message)]
633pub struct GetLiveSandboxResponse {
634    #[prost(message, optional, tag = "1")]
635    pub sandbox: ::core::option::Option<Sandbox>,
636}
637#[derive(Clone, PartialEq, ::prost::Message)]
638pub struct DeleteSandboxRequest {
639    #[prost(string, tag = "1")]
640    pub sandbox_rid: ::prost::alloc::string::String,
641}
642#[derive(Clone, PartialEq, ::prost::Message)]
643pub struct DeleteSandboxResponse {
644    #[prost(message, optional, tag = "1")]
645    pub sandbox: ::core::option::Option<Sandbox>,
646}
647#[derive(Clone, PartialEq, ::prost::Message)]
648pub struct RestartInterpreterRequest {
649    #[prost(string, tag = "1")]
650    pub sandbox_rid: ::prost::alloc::string::String,
651}
652#[derive(Clone, Copy, PartialEq, ::prost::Message)]
653pub struct RestartInterpreterResponse {}
654#[derive(Clone, PartialEq, ::prost::Message)]
655pub struct SandboxScope {
656    #[prost(string, tag = "1")]
657    pub sandbox_rid: ::prost::alloc::string::String,
658    #[prost(string, tag = "2")]
659    pub parent_rid: ::prost::alloc::string::String,
660    #[prost(string, tag = "3")]
661    pub organization_rid: ::prost::alloc::string::String,
662    #[prost(string, tag = "4")]
663    pub workspace_rid: ::prost::alloc::string::String,
664    #[prost(string, tag = "5")]
665    pub run_id: ::prost::alloc::string::String,
666}
667#[derive(Clone, PartialEq, ::prost::Message)]
668pub struct StartExecutionRequest {
669    #[prost(message, optional, tag = "1")]
670    pub scope: ::core::option::Option<SandboxScope>,
671    #[prost(message, optional, tag = "2")]
672    pub operation: ::core::option::Option<StartExecutionOperation>,
673}
674#[derive(Clone, PartialEq, ::prost::Message)]
675pub struct StartExecutionResponse {
676    #[prost(message, optional, tag = "1")]
677    pub execution: ::core::option::Option<ExecutionSnapshot>,
678}
679#[derive(Clone, PartialEq, ::prost::Message)]
680pub struct ReadExecutionRequest {
681    #[prost(message, optional, tag = "1")]
682    pub scope: ::core::option::Option<SandboxScope>,
683    #[prost(message, optional, tag = "2")]
684    pub operation: ::core::option::Option<ReadExecutionOperation>,
685}
686#[derive(Clone, PartialEq, ::prost::Message)]
687pub struct ReadExecutionResponse {
688    #[prost(message, optional, tag = "1")]
689    pub execution: ::core::option::Option<ExecutionSnapshot>,
690}
691#[derive(Clone, PartialEq, ::prost::Message)]
692pub struct WriteStdinRequest {
693    #[prost(message, optional, tag = "1")]
694    pub scope: ::core::option::Option<SandboxScope>,
695    #[prost(message, optional, tag = "2")]
696    pub operation: ::core::option::Option<WriteStdinOperation>,
697}
698#[derive(Clone, PartialEq, ::prost::Message)]
699pub struct WriteStdinResponse {
700    #[prost(message, optional, tag = "1")]
701    pub execution: ::core::option::Option<ExecutionStatus>,
702}
703#[derive(Clone, PartialEq, ::prost::Message)]
704pub struct KillExecutionRequest {
705    #[prost(message, optional, tag = "1")]
706    pub scope: ::core::option::Option<SandboxScope>,
707    #[prost(message, optional, tag = "2")]
708    pub operation: ::core::option::Option<KillExecutionOperation>,
709}
710#[derive(Clone, PartialEq, ::prost::Message)]
711pub struct KillExecutionResponse {
712    #[prost(message, optional, tag = "1")]
713    pub execution: ::core::option::Option<ExecutionStatus>,
714}
715#[derive(Clone, PartialEq, ::prost::Message)]
716pub struct GetExecutionStatusesRequest {
717    #[prost(message, optional, tag = "1")]
718    pub scope: ::core::option::Option<SandboxScope>,
719}
720#[derive(Clone, PartialEq, ::prost::Message)]
721pub struct GetExecutionStatusesResponse {
722    #[prost(message, repeated, tag = "1")]
723    pub sessions: ::prost::alloc::vec::Vec<ExecutionSession>,
724}
725#[derive(Clone, PartialEq, ::prost::Message)]
726pub struct WorkspaceFileOperationRequest {
727    #[prost(message, optional, tag = "1")]
728    pub scope: ::core::option::Option<SandboxScope>,
729    #[prost(message, optional, tag = "2")]
730    pub operation: ::core::option::Option<WorkspaceFileOperation>,
731}
732#[derive(Clone, PartialEq, ::prost::Message)]
733pub struct WorkspaceFileOperationResponse {
734    #[prost(message, optional, tag = "1")]
735    pub result: ::core::option::Option<WorkspaceFileResult>,
736}
737#[derive(Clone, PartialEq, ::prost::Message)]
738pub struct ReadFileRequest {
739    #[prost(message, optional, tag = "1")]
740    pub scope: ::core::option::Option<SandboxScope>,
741    #[prost(message, optional, tag = "2")]
742    pub operation: ::core::option::Option<ReadFileOperation>,
743}
744#[derive(Clone, PartialEq, ::prost::Message)]
745pub struct ReadFileResponse {
746    #[prost(message, optional, tag = "1")]
747    pub chunk: ::core::option::Option<FileChunk>,
748}
749#[derive(Clone, PartialEq, ::prost::Message)]
750pub struct WriteFileRequest {
751    #[prost(message, optional, tag = "1")]
752    pub scope: ::core::option::Option<SandboxScope>,
753    #[prost(message, optional, tag = "2")]
754    pub operation: ::core::option::Option<WriteFileOperation>,
755}
756#[derive(Clone, Copy, PartialEq, ::prost::Message)]
757pub struct WriteFileResponse {
758    #[prost(message, optional, tag = "1")]
759    pub result: ::core::option::Option<WriteFileResult>,
760}
761#[derive(Clone, PartialEq, ::prost::Message)]
762pub struct ExecutionSession {
763    #[prost(message, optional, tag = "1")]
764    pub status: ::core::option::Option<ExecutionStatus>,
765    #[prost(uint64, tag = "2")]
766    pub next_offset: u64,
767    #[prost(bool, tag = "3")]
768    pub terminal_pending: bool,
769}
770#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
771#[repr(i32)]
772pub enum SandboxStatus {
773    Unspecified = 0,
774    Creating = 1,
775    Ready = 2,
776    Terminating = 3,
777    Terminated = 4,
778    Failed = 5,
779}
780impl SandboxStatus {
781    /// String value of the enum field names used in the ProtoBuf definition.
782    ///
783    /// The values are not transformed in any way and thus are considered stable
784    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
785    pub fn as_str_name(&self) -> &'static str {
786        match self {
787            Self::Unspecified => "SANDBOX_STATUS_UNSPECIFIED",
788            Self::Creating => "SANDBOX_STATUS_CREATING",
789            Self::Ready => "SANDBOX_STATUS_READY",
790            Self::Terminating => "SANDBOX_STATUS_TERMINATING",
791            Self::Terminated => "SANDBOX_STATUS_TERMINATED",
792            Self::Failed => "SANDBOX_STATUS_FAILED",
793        }
794    }
795    /// Creates an enum from field names used in the ProtoBuf definition.
796    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
797        match value {
798            "SANDBOX_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
799            "SANDBOX_STATUS_CREATING" => Some(Self::Creating),
800            "SANDBOX_STATUS_READY" => Some(Self::Ready),
801            "SANDBOX_STATUS_TERMINATING" => Some(Self::Terminating),
802            "SANDBOX_STATUS_TERMINATED" => Some(Self::Terminated),
803            "SANDBOX_STATUS_FAILED" => Some(Self::Failed),
804            _ => None,
805        }
806    }
807}
808/// Generated client implementations.
809pub mod internal_code_sandbox_service_client {
810    #![allow(
811        unused_variables,
812        dead_code,
813        missing_docs,
814        clippy::wildcard_imports,
815        clippy::let_unit_value,
816    )]
817    use tonic::codegen::*;
818    use tonic::codegen::http::Uri;
819    #[derive(Debug, Clone)]
820    pub struct InternalCodeSandboxServiceClient<T> {
821        inner: tonic::client::Grpc<T>,
822    }
823    impl InternalCodeSandboxServiceClient<tonic::transport::Channel> {
824        /// Attempt to create a new client by connecting to a given endpoint.
825        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
826        where
827            D: TryInto<tonic::transport::Endpoint>,
828            D::Error: Into<StdError>,
829        {
830            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
831            Ok(Self::new(conn))
832        }
833    }
834    impl<T> InternalCodeSandboxServiceClient<T>
835    where
836        T: tonic::client::GrpcService<tonic::body::Body>,
837        T::Error: Into<StdError>,
838        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
839        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
840    {
841        pub fn new(inner: T) -> Self {
842            let inner = tonic::client::Grpc::new(inner);
843            Self { inner }
844        }
845        pub fn with_origin(inner: T, origin: Uri) -> Self {
846            let inner = tonic::client::Grpc::with_origin(inner, origin);
847            Self { inner }
848        }
849        pub fn with_interceptor<F>(
850            inner: T,
851            interceptor: F,
852        ) -> InternalCodeSandboxServiceClient<InterceptedService<T, F>>
853        where
854            F: tonic::service::Interceptor,
855            T::ResponseBody: Default,
856            T: tonic::codegen::Service<
857                http::Request<tonic::body::Body>,
858                Response = http::Response<
859                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
860                >,
861            >,
862            <T as tonic::codegen::Service<
863                http::Request<tonic::body::Body>,
864            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
865        {
866            InternalCodeSandboxServiceClient::new(
867                InterceptedService::new(inner, interceptor),
868            )
869        }
870        /// Compress requests with the given encoding.
871        ///
872        /// This requires the server to support it otherwise it might respond with an
873        /// error.
874        #[must_use]
875        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
876            self.inner = self.inner.send_compressed(encoding);
877            self
878        }
879        /// Enable decompressing responses.
880        #[must_use]
881        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
882            self.inner = self.inner.accept_compressed(encoding);
883            self
884        }
885        /// Limits the maximum size of a decoded message.
886        ///
887        /// Default: `4MB`
888        #[must_use]
889        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
890            self.inner = self.inner.max_decoding_message_size(limit);
891            self
892        }
893        /// Limits the maximum size of an encoded message.
894        ///
895        /// Default: `usize::MAX`
896        #[must_use]
897        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
898            self.inner = self.inner.max_encoding_message_size(limit);
899            self
900        }
901        pub async fn create_sandbox(
902            &mut self,
903            request: impl tonic::IntoRequest<super::CreateSandboxRequest>,
904        ) -> std::result::Result<
905            tonic::Response<super::CreateSandboxResponse>,
906            tonic::Status,
907        > {
908            self.inner
909                .ready()
910                .await
911                .map_err(|e| {
912                    tonic::Status::unknown(
913                        format!("Service was not ready: {}", e.into()),
914                    )
915                })?;
916            let codec = tonic::codec::ProstCodec::default();
917            let path = http::uri::PathAndQuery::from_static(
918                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/CreateSandbox",
919            );
920            let mut req = request.into_request();
921            req.extensions_mut()
922                .insert(
923                    GrpcMethod::new(
924                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
925                        "CreateSandbox",
926                    ),
927                );
928            self.inner.unary(req, path, codec).await
929        }
930        pub async fn get_sandbox(
931            &mut self,
932            request: impl tonic::IntoRequest<super::GetSandboxRequest>,
933        ) -> std::result::Result<
934            tonic::Response<super::GetSandboxResponse>,
935            tonic::Status,
936        > {
937            self.inner
938                .ready()
939                .await
940                .map_err(|e| {
941                    tonic::Status::unknown(
942                        format!("Service was not ready: {}", e.into()),
943                    )
944                })?;
945            let codec = tonic::codec::ProstCodec::default();
946            let path = http::uri::PathAndQuery::from_static(
947                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/GetSandbox",
948            );
949            let mut req = request.into_request();
950            req.extensions_mut()
951                .insert(
952                    GrpcMethod::new(
953                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
954                        "GetSandbox",
955                    ),
956                );
957            self.inner.unary(req, path, codec).await
958        }
959        pub async fn get_live_sandbox(
960            &mut self,
961            request: impl tonic::IntoRequest<super::GetLiveSandboxRequest>,
962        ) -> std::result::Result<
963            tonic::Response<super::GetLiveSandboxResponse>,
964            tonic::Status,
965        > {
966            self.inner
967                .ready()
968                .await
969                .map_err(|e| {
970                    tonic::Status::unknown(
971                        format!("Service was not ready: {}", e.into()),
972                    )
973                })?;
974            let codec = tonic::codec::ProstCodec::default();
975            let path = http::uri::PathAndQuery::from_static(
976                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/GetLiveSandbox",
977            );
978            let mut req = request.into_request();
979            req.extensions_mut()
980                .insert(
981                    GrpcMethod::new(
982                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
983                        "GetLiveSandbox",
984                    ),
985                );
986            self.inner.unary(req, path, codec).await
987        }
988        pub async fn delete_sandbox(
989            &mut self,
990            request: impl tonic::IntoRequest<super::DeleteSandboxRequest>,
991        ) -> std::result::Result<
992            tonic::Response<super::DeleteSandboxResponse>,
993            tonic::Status,
994        > {
995            self.inner
996                .ready()
997                .await
998                .map_err(|e| {
999                    tonic::Status::unknown(
1000                        format!("Service was not ready: {}", e.into()),
1001                    )
1002                })?;
1003            let codec = tonic::codec::ProstCodec::default();
1004            let path = http::uri::PathAndQuery::from_static(
1005                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/DeleteSandbox",
1006            );
1007            let mut req = request.into_request();
1008            req.extensions_mut()
1009                .insert(
1010                    GrpcMethod::new(
1011                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1012                        "DeleteSandbox",
1013                    ),
1014                );
1015            self.inner.unary(req, path, codec).await
1016        }
1017        pub async fn restart_interpreter(
1018            &mut self,
1019            request: impl tonic::IntoRequest<super::RestartInterpreterRequest>,
1020        ) -> std::result::Result<
1021            tonic::Response<super::RestartInterpreterResponse>,
1022            tonic::Status,
1023        > {
1024            self.inner
1025                .ready()
1026                .await
1027                .map_err(|e| {
1028                    tonic::Status::unknown(
1029                        format!("Service was not ready: {}", e.into()),
1030                    )
1031                })?;
1032            let codec = tonic::codec::ProstCodec::default();
1033            let path = http::uri::PathAndQuery::from_static(
1034                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/RestartInterpreter",
1035            );
1036            let mut req = request.into_request();
1037            req.extensions_mut()
1038                .insert(
1039                    GrpcMethod::new(
1040                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1041                        "RestartInterpreter",
1042                    ),
1043                );
1044            self.inner.unary(req, path, codec).await
1045        }
1046        pub async fn start_execution(
1047            &mut self,
1048            request: impl tonic::IntoRequest<super::StartExecutionRequest>,
1049        ) -> std::result::Result<
1050            tonic::Response<super::StartExecutionResponse>,
1051            tonic::Status,
1052        > {
1053            self.inner
1054                .ready()
1055                .await
1056                .map_err(|e| {
1057                    tonic::Status::unknown(
1058                        format!("Service was not ready: {}", e.into()),
1059                    )
1060                })?;
1061            let codec = tonic::codec::ProstCodec::default();
1062            let path = http::uri::PathAndQuery::from_static(
1063                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/StartExecution",
1064            );
1065            let mut req = request.into_request();
1066            req.extensions_mut()
1067                .insert(
1068                    GrpcMethod::new(
1069                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1070                        "StartExecution",
1071                    ),
1072                );
1073            self.inner.unary(req, path, codec).await
1074        }
1075        pub async fn read_execution(
1076            &mut self,
1077            request: impl tonic::IntoRequest<super::ReadExecutionRequest>,
1078        ) -> std::result::Result<
1079            tonic::Response<super::ReadExecutionResponse>,
1080            tonic::Status,
1081        > {
1082            self.inner
1083                .ready()
1084                .await
1085                .map_err(|e| {
1086                    tonic::Status::unknown(
1087                        format!("Service was not ready: {}", e.into()),
1088                    )
1089                })?;
1090            let codec = tonic::codec::ProstCodec::default();
1091            let path = http::uri::PathAndQuery::from_static(
1092                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/ReadExecution",
1093            );
1094            let mut req = request.into_request();
1095            req.extensions_mut()
1096                .insert(
1097                    GrpcMethod::new(
1098                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1099                        "ReadExecution",
1100                    ),
1101                );
1102            self.inner.unary(req, path, codec).await
1103        }
1104        pub async fn write_stdin(
1105            &mut self,
1106            request: impl tonic::IntoRequest<super::WriteStdinRequest>,
1107        ) -> std::result::Result<
1108            tonic::Response<super::WriteStdinResponse>,
1109            tonic::Status,
1110        > {
1111            self.inner
1112                .ready()
1113                .await
1114                .map_err(|e| {
1115                    tonic::Status::unknown(
1116                        format!("Service was not ready: {}", e.into()),
1117                    )
1118                })?;
1119            let codec = tonic::codec::ProstCodec::default();
1120            let path = http::uri::PathAndQuery::from_static(
1121                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/WriteStdin",
1122            );
1123            let mut req = request.into_request();
1124            req.extensions_mut()
1125                .insert(
1126                    GrpcMethod::new(
1127                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1128                        "WriteStdin",
1129                    ),
1130                );
1131            self.inner.unary(req, path, codec).await
1132        }
1133        pub async fn kill_execution(
1134            &mut self,
1135            request: impl tonic::IntoRequest<super::KillExecutionRequest>,
1136        ) -> std::result::Result<
1137            tonic::Response<super::KillExecutionResponse>,
1138            tonic::Status,
1139        > {
1140            self.inner
1141                .ready()
1142                .await
1143                .map_err(|e| {
1144                    tonic::Status::unknown(
1145                        format!("Service was not ready: {}", e.into()),
1146                    )
1147                })?;
1148            let codec = tonic::codec::ProstCodec::default();
1149            let path = http::uri::PathAndQuery::from_static(
1150                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/KillExecution",
1151            );
1152            let mut req = request.into_request();
1153            req.extensions_mut()
1154                .insert(
1155                    GrpcMethod::new(
1156                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1157                        "KillExecution",
1158                    ),
1159                );
1160            self.inner.unary(req, path, codec).await
1161        }
1162        pub async fn get_execution_statuses(
1163            &mut self,
1164            request: impl tonic::IntoRequest<super::GetExecutionStatusesRequest>,
1165        ) -> std::result::Result<
1166            tonic::Response<super::GetExecutionStatusesResponse>,
1167            tonic::Status,
1168        > {
1169            self.inner
1170                .ready()
1171                .await
1172                .map_err(|e| {
1173                    tonic::Status::unknown(
1174                        format!("Service was not ready: {}", e.into()),
1175                    )
1176                })?;
1177            let codec = tonic::codec::ProstCodec::default();
1178            let path = http::uri::PathAndQuery::from_static(
1179                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/GetExecutionStatuses",
1180            );
1181            let mut req = request.into_request();
1182            req.extensions_mut()
1183                .insert(
1184                    GrpcMethod::new(
1185                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1186                        "GetExecutionStatuses",
1187                    ),
1188                );
1189            self.inner.unary(req, path, codec).await
1190        }
1191        pub async fn workspace_file_operation(
1192            &mut self,
1193            request: impl tonic::IntoRequest<super::WorkspaceFileOperationRequest>,
1194        ) -> std::result::Result<
1195            tonic::Response<super::WorkspaceFileOperationResponse>,
1196            tonic::Status,
1197        > {
1198            self.inner
1199                .ready()
1200                .await
1201                .map_err(|e| {
1202                    tonic::Status::unknown(
1203                        format!("Service was not ready: {}", e.into()),
1204                    )
1205                })?;
1206            let codec = tonic::codec::ProstCodec::default();
1207            let path = http::uri::PathAndQuery::from_static(
1208                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/WorkspaceFileOperation",
1209            );
1210            let mut req = request.into_request();
1211            req.extensions_mut()
1212                .insert(
1213                    GrpcMethod::new(
1214                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1215                        "WorkspaceFileOperation",
1216                    ),
1217                );
1218            self.inner.unary(req, path, codec).await
1219        }
1220        pub async fn read_file(
1221            &mut self,
1222            request: impl tonic::IntoRequest<super::ReadFileRequest>,
1223        ) -> std::result::Result<
1224            tonic::Response<tonic::codec::Streaming<super::ReadFileResponse>>,
1225            tonic::Status,
1226        > {
1227            self.inner
1228                .ready()
1229                .await
1230                .map_err(|e| {
1231                    tonic::Status::unknown(
1232                        format!("Service was not ready: {}", e.into()),
1233                    )
1234                })?;
1235            let codec = tonic::codec::ProstCodec::default();
1236            let path = http::uri::PathAndQuery::from_static(
1237                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/ReadFile",
1238            );
1239            let mut req = request.into_request();
1240            req.extensions_mut()
1241                .insert(
1242                    GrpcMethod::new(
1243                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1244                        "ReadFile",
1245                    ),
1246                );
1247            self.inner.server_streaming(req, path, codec).await
1248        }
1249        pub async fn write_file(
1250            &mut self,
1251            request: impl tonic::IntoStreamingRequest<Message = super::WriteFileRequest>,
1252        ) -> std::result::Result<
1253            tonic::Response<super::WriteFileResponse>,
1254            tonic::Status,
1255        > {
1256            self.inner
1257                .ready()
1258                .await
1259                .map_err(|e| {
1260                    tonic::Status::unknown(
1261                        format!("Service was not ready: {}", e.into()),
1262                    )
1263                })?;
1264            let codec = tonic::codec::ProstCodec::default();
1265            let path = http::uri::PathAndQuery::from_static(
1266                "/nominal.internalcodesandbox.v1.InternalCodeSandboxService/WriteFile",
1267            );
1268            let mut req = request.into_streaming_request();
1269            req.extensions_mut()
1270                .insert(
1271                    GrpcMethod::new(
1272                        "nominal.internalcodesandbox.v1.InternalCodeSandboxService",
1273                        "WriteFile",
1274                    ),
1275                );
1276            self.inner.client_streaming(req, path, codec).await
1277        }
1278    }
1279}
nominal_api_proto/proto/nominal.internalcodesandbox.v1.rs

nominal_api_proto/proto/
nominal.internalcodesandbox.v1.rs
