nominal-api 0.1256.0

API bindings for the Nominal platform
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

#[derive(
    Debug,
    Clone,
    conjure_object::serde::Serialize,
    conjure_object::serde::Deserialize,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash
)]
#[serde(crate = "conjure_object::serde")]
#[conjure_object::private::staged_builder::staged_builder]
#[builder(crate = conjure_object::private::staged_builder, update, inline)]
pub struct RegisterContainerizedExtractorRequest {
    #[builder(into)]
    #[serde(rename = "name")]
    name: String,
    #[builder(default, into)]
    #[serde(rename = "description", skip_serializing_if = "Option::is_none", default)]
    description: Option<String>,
    #[builder(
        default,
        custom(
            type = impl
            Into<Option<super::DockerImageSource>>,
            convert = |v|v.into().map(Box::new)
        )
    )]
    #[serde(rename = "image", skip_serializing_if = "Option::is_none", default)]
    image: Option<Box<super::DockerImageSource>>,
    #[builder(default, into)]
    #[serde(
        rename = "containerImageRid",
        skip_serializing_if = "Option::is_none",
        default
    )]
    container_image_rid: Option<conjure_object::ResourceIdentifier>,
    #[builder(default, list(item(type = super::FileExtractionInput)))]
    #[serde(rename = "inputs", skip_serializing_if = "Vec::is_empty", default)]
    inputs: Vec<super::FileExtractionInput>,
    #[builder(default, list(item(type = super::FileExtractionParameter)))]
    #[serde(rename = "parameters", skip_serializing_if = "Vec::is_empty", default)]
    parameters: Vec<super::FileExtractionParameter>,
    #[builder(default, map(key(type = String, into), value(type = String, into)))]
    #[serde(
        rename = "properties",
        skip_serializing_if = "std::collections::BTreeMap::is_empty",
        default
    )]
    properties: std::collections::BTreeMap<String, String>,
    #[builder(default, set(item(type = String, into)))]
    #[serde(
        rename = "labels",
        skip_serializing_if = "std::collections::BTreeSet::is_empty",
        default
    )]
    labels: std::collections::BTreeSet<String>,
    #[serde(rename = "workspace")]
    workspace: conjure_object::ResourceIdentifier,
    #[builder(
        default,
        custom(
            type = impl
            Into<Option<super::TimestampMetadata>>,
            convert = |v|v.into().map(Box::new)
        )
    )]
    #[serde(
        rename = "timestampMetadata",
        skip_serializing_if = "Option::is_none",
        default
    )]
    timestamp_metadata: Option<Box<super::TimestampMetadata>>,
    #[builder(default, into)]
    #[serde(
        rename = "outputFileFormat",
        skip_serializing_if = "Option::is_none",
        default
    )]
    output_file_format: Option<super::FileOutputFormat>,
}
impl RegisterContainerizedExtractorRequest {
    /// Constructs a new instance of the type.
    #[inline]
    pub fn new(
        name: impl Into<String>,
        workspace: conjure_object::ResourceIdentifier,
    ) -> Self {
        Self::builder().name(name).workspace(workspace).build()
    }
    #[inline]
    pub fn name(&self) -> &str {
        &*self.name
    }
    #[inline]
    pub fn description(&self) -> Option<&str> {
        self.description.as_ref().map(|o| &**o)
    }
    /// Deprecated: use containerImageRid instead for self-hosted images.
    /// Container image for the extractor. Used for external registries.
    /// Ignored when containerImageRid is set.
    #[deprecated(note = "Use containerImageRid for self-hosted images.")]
    #[inline]
    pub fn image(&self) -> Option<&super::DockerImageSource> {
        self.image.as_ref().map(|o| &**o)
    }
    /// RID of a self-hosted container image. When set, the extractor uses the internal registry
    /// and the image field is ignored.
    #[inline]
    pub fn container_image_rid(&self) -> Option<&conjure_object::ResourceIdentifier> {
        self.container_image_rid.as_ref().map(|o| &*o)
    }
    /// payload must match input defined in containerized extraction
    #[inline]
    pub fn inputs(&self) -> &[super::FileExtractionInput] {
        &*self.inputs
    }
    /// Describes the parameters of the extractor.
    #[inline]
    pub fn parameters(&self) -> &[super::FileExtractionParameter] {
        &*self.parameters
    }
    #[inline]
    pub fn properties(&self) -> &std::collections::BTreeMap<String, String> {
        &self.properties
    }
    #[inline]
    pub fn labels(&self) -> &std::collections::BTreeSet<String> {
        &self.labels
    }
    /// The workspace in which to create the extractor
    #[inline]
    pub fn workspace(&self) -> &conjure_object::ResourceIdentifier {
        &self.workspace
    }
    /// Metadata about the intermediate parquet this extractor will produce.
    /// If not set, timestamp metadata must be provided at ingest time.
    #[inline]
    pub fn timestamp_metadata(&self) -> Option<&super::TimestampMetadata> {
        self.timestamp_metadata.as_ref().map(|o| &**o)
    }
    /// The format of the output file. Currently only "parquet", "csv", "parquet.tar" are supported
    #[inline]
    pub fn output_file_format(&self) -> Option<&super::FileOutputFormat> {
        self.output_file_format.as_ref().map(|o| &*o)
    }
}