nifi_rust_client/dynamic/
types.rs

1// @generated — do not edit; run `cargo run -p nifi-openapi-gen`
2
3#![allow(dead_code, private_interfaces)]
4
5use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Default, Deserialize, Serialize)]
8#[serde(rename_all = "camelCase")]
9pub struct AboutDto {
10    #[serde(rename = "buildBranch")]
11    pub build_branch: Option<String>,
12    #[serde(rename = "buildRevision")]
13    pub build_revision: Option<String>,
14    #[serde(rename = "buildTag")]
15    pub build_tag: Option<String>,
16    #[serde(rename = "buildTimestamp")]
17    pub build_timestamp: Option<String>,
18    #[serde(rename = "contentViewerUrl")]
19    pub content_viewer_url: Option<String>,
20    pub timezone: Option<String>,
21    pub title: Option<String>,
22    pub uri: Option<String>,
23    pub version: Option<String>,
24}
25
26#[derive(Debug, Clone, Default, Deserialize, Serialize)]
27#[serde(rename_all = "camelCase")]
28pub(crate) struct AboutEntity {
29    pub about: Option<AboutDto>,
30}
31
32#[derive(Debug, Clone, Default, Deserialize, Serialize)]
33#[serde(rename_all = "camelCase")]
34pub struct AccessPolicyDto {
35    pub action: Option<String>,
36    #[serde(rename = "componentReference")]
37    pub component_reference: Option<ComponentReferenceEntity>,
38    pub configurable: Option<bool>,
39    pub id: Option<String>,
40    #[serde(rename = "parentGroupId")]
41    pub parent_group_id: Option<String>,
42    pub position: Option<PositionDto>,
43    pub resource: Option<String>,
44    #[serde(rename = "userGroups")]
45    pub user_groups: Option<Vec<TenantEntity>>,
46    pub users: Option<Vec<TenantEntity>>,
47    #[serde(rename = "versionedComponentId")]
48    pub versioned_component_id: Option<String>,
49}
50
51#[derive(Debug, Clone, Default, Deserialize, Serialize)]
52#[serde(rename_all = "camelCase")]
53pub struct AccessPolicyEntity {
54    pub bulletins: Option<Vec<BulletinEntity>>,
55    pub component: Option<AccessPolicyDto>,
56    #[serde(rename = "disconnectedNodeAcknowledged")]
57    pub disconnected_node_acknowledged: Option<bool>,
58    pub generated: Option<String>,
59    pub id: Option<String>,
60    pub permissions: Option<PermissionsDto>,
61    pub position: Option<PositionDto>,
62    pub revision: Option<RevisionDto>,
63    pub uri: Option<String>,
64}
65
66#[derive(Debug, Clone, Default, Deserialize, Serialize)]
67#[serde(rename_all = "camelCase")]
68pub struct AccessPolicySummaryDto {
69    pub action: Option<String>,
70    #[serde(rename = "componentReference")]
71    pub component_reference: Option<ComponentReferenceEntity>,
72    pub configurable: Option<bool>,
73    pub id: Option<String>,
74    #[serde(rename = "parentGroupId")]
75    pub parent_group_id: Option<String>,
76    pub position: Option<PositionDto>,
77    pub resource: Option<String>,
78    #[serde(rename = "versionedComponentId")]
79    pub versioned_component_id: Option<String>,
80}
81
82#[derive(Debug, Clone, Default, Deserialize, Serialize)]
83#[serde(rename_all = "camelCase")]
84pub struct AccessPolicySummaryEntity {
85    pub bulletins: Option<Vec<BulletinEntity>>,
86    pub component: Option<AccessPolicySummaryDto>,
87    #[serde(rename = "disconnectedNodeAcknowledged")]
88    pub disconnected_node_acknowledged: Option<bool>,
89    pub id: Option<String>,
90    pub permissions: Option<PermissionsDto>,
91    pub position: Option<PositionDto>,
92    pub revision: Option<RevisionDto>,
93    pub uri: Option<String>,
94}
95
96#[derive(Debug, Clone, Default, Deserialize, Serialize)]
97#[serde(rename_all = "camelCase")]
98pub struct ActionDetailsDto {}
99
100#[derive(Debug, Clone, Default, Deserialize, Serialize)]
101#[serde(rename_all = "camelCase")]
102pub struct ActionDto {
103    #[serde(rename = "actionDetails")]
104    pub action_details: Option<ActionDetailsDto>,
105    #[serde(rename = "componentDetails")]
106    pub component_details: Option<ComponentDetailsDto>,
107    pub id: Option<i32>,
108    pub operation: Option<String>,
109    #[serde(rename = "sourceId")]
110    pub source_id: Option<String>,
111    #[serde(rename = "sourceName")]
112    pub source_name: Option<String>,
113    #[serde(rename = "sourceType")]
114    pub source_type: Option<String>,
115    pub timestamp: Option<String>,
116    #[serde(rename = "userIdentity")]
117    pub user_identity: Option<String>,
118}
119
120#[derive(Debug, Clone, Default, Deserialize, Serialize)]
121#[serde(rename_all = "camelCase")]
122pub struct ActionEntity {
123    pub action: Option<ActionDto>,
124    #[serde(rename = "canRead")]
125    pub can_read: Option<bool>,
126    pub id: Option<i32>,
127    #[serde(rename = "sourceId")]
128    pub source_id: Option<String>,
129    pub timestamp: Option<String>,
130}
131
132#[derive(Debug, Clone, Default, Deserialize, Serialize)]
133#[serde(rename_all = "camelCase")]
134pub struct ActivateControllerServicesEntity {
135    pub components: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
136    #[serde(rename = "disconnectedNodeAcknowledged")]
137    pub disconnected_node_acknowledged: Option<bool>,
138    pub id: Option<String>,
139    pub state: Option<String>,
140}
141
142#[derive(Debug, Clone, Default, Deserialize, Serialize)]
143#[serde(rename_all = "camelCase")]
144pub struct AdditionalDetailsEntity {
145    #[serde(rename = "additionalDetails")]
146    pub additional_details: Option<String>,
147}
148
149#[derive(Debug, Clone, Default, Deserialize, Serialize)]
150#[serde(rename_all = "camelCase")]
151pub struct AffectedComponentDto {
152    #[serde(rename = "activeThreadCount")]
153    pub active_thread_count: Option<i32>,
154    pub id: Option<String>,
155    pub name: Option<String>,
156    #[serde(rename = "processGroupId")]
157    pub process_group_id: Option<String>,
158    #[serde(rename = "referenceType")]
159    pub reference_type: Option<String>,
160    pub state: Option<String>,
161    #[serde(rename = "validationErrors")]
162    pub validation_errors: Option<Vec<String>>,
163}
164
165#[derive(Debug, Clone, Default, Deserialize, Serialize)]
166#[serde(rename_all = "camelCase")]
167pub struct AffectedComponentEntity {
168    pub bulletins: Option<Vec<BulletinEntity>>,
169    pub component: Option<AffectedComponentDto>,
170    #[serde(rename = "disconnectedNodeAcknowledged")]
171    pub disconnected_node_acknowledged: Option<bool>,
172    pub id: Option<String>,
173    pub permissions: Option<PermissionsDto>,
174    pub position: Option<PositionDto>,
175    #[serde(rename = "processGroup")]
176    pub process_group: Option<ProcessGroupNameDto>,
177    #[serde(rename = "referenceType")]
178    pub reference_type: Option<String>,
179    pub revision: Option<RevisionDto>,
180    pub uri: Option<String>,
181}
182
183#[derive(Debug, Clone, Default, Deserialize, Serialize)]
184#[serde(rename_all = "camelCase")]
185pub struct AllowableValueDto {
186    pub description: Option<String>,
187    #[serde(rename = "displayName")]
188    pub display_name: Option<String>,
189    pub value: Option<String>,
190}
191
192#[derive(Debug, Clone, Default, Deserialize, Serialize)]
193#[serde(rename_all = "camelCase")]
194pub struct AllowableValueEntity {
195    #[serde(rename = "allowableValue")]
196    pub allowable_value: Option<AllowableValueDto>,
197    #[serde(rename = "canRead")]
198    pub can_read: Option<bool>,
199}
200
201#[derive(Debug, Clone, Default, Deserialize, Serialize)]
202#[serde(rename_all = "camelCase")]
203pub struct AssetDto {
204    pub digest: Option<String>,
205    pub id: Option<String>,
206    #[serde(rename = "missingContent")]
207    pub missing_content: Option<bool>,
208    pub name: Option<String>,
209}
210
211#[derive(Debug, Clone, Default, Deserialize, Serialize)]
212#[serde(rename_all = "camelCase")]
213pub(crate) struct AssetEntity {
214    pub asset: Option<AssetDto>,
215}
216
217#[derive(Debug, Clone, Default, Deserialize, Serialize)]
218#[serde(rename_all = "camelCase")]
219pub struct AssetReferenceDto {
220    pub id: Option<String>,
221    pub name: Option<String>,
222}
223
224#[derive(Debug, Clone, Default, Deserialize, Serialize)]
225#[serde(rename_all = "camelCase")]
226pub struct AssetsEntity {
227    pub assets: Option<Vec<AssetEntity>>,
228}
229
230#[derive(Debug, Clone, Default, Deserialize, Serialize)]
231#[serde(rename_all = "camelCase")]
232pub struct Attribute {
233    pub description: Option<String>,
234    pub name: Option<String>,
235}
236
237#[derive(Debug, Clone, Default, Deserialize, Serialize)]
238#[serde(rename_all = "camelCase")]
239pub struct AttributeDto {
240    pub name: Option<String>,
241    #[serde(rename = "previousValue")]
242    pub previous_value: Option<String>,
243    pub value: Option<String>,
244}
245
246#[derive(Debug, Clone, Default, Deserialize, Serialize)]
247#[serde(rename_all = "camelCase")]
248pub struct AuthenticationConfigurationDto {
249    #[serde(rename = "externalLoginRequired")]
250    pub external_login_required: Option<bool>,
251    #[serde(rename = "loginSupported")]
252    pub login_supported: Option<bool>,
253    #[serde(rename = "loginUri")]
254    pub login_uri: Option<String>,
255    #[serde(rename = "logoutUri")]
256    pub logout_uri: Option<String>,
257}
258
259#[derive(Debug, Clone, Default, Deserialize, Serialize)]
260#[serde(rename_all = "camelCase")]
261pub(crate) struct AuthenticationConfigurationEntity {
262    pub authentication_configuration: Option<AuthenticationConfigurationDto>,
263}
264
265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
266#[serde(rename_all = "camelCase")]
267pub struct BannerDto {
268    #[serde(rename = "footerText")]
269    pub footer_text: Option<String>,
270    #[serde(rename = "headerText")]
271    pub header_text: Option<String>,
272}
273
274#[derive(Debug, Clone, Default, Deserialize, Serialize)]
275#[serde(rename_all = "camelCase")]
276pub(crate) struct BannerEntity {
277    pub banners: Option<BannerDto>,
278}
279
280#[derive(Debug, Clone, Default, Deserialize, Serialize)]
281#[serde(rename_all = "camelCase")]
282pub struct BatchSettingsDto {
283    pub count: Option<i32>,
284    pub duration: Option<String>,
285    pub size: Option<String>,
286}
287
288#[derive(Debug, Clone, Default, Deserialize, Serialize)]
289#[serde(rename_all = "camelCase")]
290pub struct BatchSize {
291    pub count: Option<i32>,
292    pub duration: Option<String>,
293    pub size: Option<String>,
294}
295
296#[derive(Debug, Clone, Default, Deserialize, Serialize)]
297#[serde(rename_all = "camelCase")]
298pub struct BuildInfo {
299    pub compiler: Option<String>,
300    #[serde(rename = "compilerFlags")]
301    pub compiler_flags: Option<String>,
302    pub revision: Option<String>,
303    #[serde(rename = "targetArch")]
304    pub target_arch: Option<String>,
305    pub timestamp: Option<i64>,
306    pub version: Option<String>,
307}
308
309#[derive(Debug, Clone, Default, Deserialize, Serialize)]
310#[serde(rename_all = "camelCase")]
311pub struct BulletinBoardDto {
312    pub bulletins: Option<Vec<BulletinEntity>>,
313    pub generated: Option<String>,
314}
315
316#[derive(Debug, Clone, Default, Deserialize, Serialize)]
317#[serde(rename_all = "camelCase")]
318pub(crate) struct BulletinBoardEntity {
319    pub bulletin_board: Option<BulletinBoardDto>,
320}
321
322#[derive(Debug, Clone, Default, Deserialize, Serialize)]
323#[serde(rename_all = "camelCase")]
324pub struct BulletinBoardPatternParameter {
325    pub pattern: Option<serde_json::Value>,
326    #[serde(rename = "rawPattern")]
327    pub raw_pattern: Option<String>,
328}
329
330#[derive(Debug, Clone, Default, Deserialize, Serialize)]
331#[serde(rename_all = "camelCase")]
332pub struct BulletinDto {
333    pub category: Option<String>,
334    #[serde(rename = "groupId")]
335    pub group_id: Option<String>,
336    pub id: Option<i64>,
337    pub level: Option<String>,
338    pub message: Option<String>,
339    #[serde(rename = "nodeAddress")]
340    pub node_address: Option<String>,
341    #[serde(rename = "sourceId")]
342    pub source_id: Option<String>,
343    #[serde(rename = "sourceName")]
344    pub source_name: Option<String>,
345    #[serde(rename = "sourceType")]
346    pub source_type: Option<String>,
347    #[serde(rename = "stackTrace")]
348    pub stack_trace: Option<String>,
349    pub timestamp: Option<String>,
350    #[serde(rename = "timestampIso")]
351    pub timestamp_iso: Option<String>,
352}
353
354#[derive(Debug, Clone, Default, Deserialize, Serialize)]
355#[serde(rename_all = "camelCase")]
356pub struct BulletinEntity {
357    pub bulletin: Option<BulletinDto>,
358    #[serde(rename = "canRead")]
359    pub can_read: Option<bool>,
360    #[serde(rename = "groupId")]
361    pub group_id: Option<String>,
362    pub id: Option<i64>,
363    #[serde(rename = "nodeAddress")]
364    pub node_address: Option<String>,
365    #[serde(rename = "sourceId")]
366    pub source_id: Option<String>,
367    pub timestamp: Option<String>,
368    #[serde(rename = "timestampIso")]
369    pub timestamp_iso: Option<String>,
370}
371
372#[derive(Debug, Clone, Default, Deserialize, Serialize)]
373#[serde(rename_all = "camelCase")]
374pub struct Bundle {
375    pub artifact: Option<String>,
376    pub group: Option<String>,
377    pub version: Option<String>,
378}
379
380#[derive(Debug, Clone, Default, Deserialize, Serialize)]
381#[serde(rename_all = "camelCase")]
382pub struct BundleDto {
383    pub artifact: Option<String>,
384    pub group: Option<String>,
385    pub version: Option<String>,
386}
387
388#[derive(Debug, Clone, Default, Deserialize, Serialize)]
389#[serde(rename_all = "camelCase")]
390pub struct ClearBulletinsForGroupRequestEntity {
391    pub components: Option<Vec<String>>,
392    #[serde(rename = "fromTimestamp")]
393    pub from_timestamp: Option<String>,
394    pub id: Option<String>,
395}
396
397#[derive(Debug, Clone, Default, Deserialize, Serialize)]
398#[serde(rename_all = "camelCase")]
399pub struct ClearBulletinsForGroupResultsEntity {
400    #[serde(rename = "bulletinsCleared")]
401    pub bulletins_cleared: Option<i32>,
402}
403
404#[derive(Debug, Clone, Default, Deserialize, Serialize)]
405#[serde(rename_all = "camelCase")]
406pub struct ClearBulletinsRequestEntity {
407    #[serde(rename = "fromTimestamp")]
408    pub from_timestamp: Option<String>,
409}
410
411#[derive(Debug, Clone, Default, Deserialize, Serialize)]
412#[serde(rename_all = "camelCase")]
413pub struct ClearBulletinsResultEntity {
414    pub bulletins: Option<Vec<BulletinEntity>>,
415    #[serde(rename = "bulletinsCleared")]
416    pub bulletins_cleared: Option<i32>,
417    #[serde(rename = "componentId")]
418    pub component_id: Option<String>,
419}
420
421#[derive(Debug, Clone, Default, Deserialize, Serialize)]
422#[serde(rename_all = "camelCase")]
423pub struct ClientIdParameter {
424    #[serde(rename = "clientId")]
425    pub client_id: Option<String>,
426}
427
428#[derive(Debug, Clone, Default, Deserialize, Serialize)]
429#[serde(rename_all = "camelCase")]
430pub struct ClusterDto {
431    pub generated: Option<String>,
432    pub nodes: Option<Vec<NodeDto>>,
433}
434
435#[derive(Debug, Clone, Default, Deserialize, Serialize)]
436#[serde(rename_all = "camelCase")]
437pub(crate) struct ClusterEntity {
438    pub cluster: Option<ClusterDto>,
439}
440
441#[derive(Debug, Clone, Default, Deserialize, Serialize)]
442#[serde(rename_all = "camelCase")]
443pub struct ClusterSearchResultsEntity {
444    #[serde(rename = "nodeResults")]
445    pub node_results: Option<Vec<NodeSearchResultDto>>,
446}
447
448#[derive(Debug, Clone, Default, Deserialize, Serialize)]
449#[serde(rename_all = "camelCase")]
450pub struct ClusterSummaryDto {
451    pub clustered: Option<bool>,
452    #[serde(rename = "connectedNodeCount")]
453    pub connected_node_count: Option<i32>,
454    #[serde(rename = "connectedNodes")]
455    pub connected_nodes: Option<String>,
456    #[serde(rename = "connectedToCluster")]
457    pub connected_to_cluster: Option<bool>,
458    #[serde(rename = "totalNodeCount")]
459    pub total_node_count: Option<i32>,
460}
461
462#[derive(Debug, Clone, Default, Deserialize, Serialize)]
463#[serde(rename_all = "camelCase")]
464pub(crate) struct ClusterSummaryEntity {
465    pub cluster_summary: Option<ClusterSummaryDto>,
466}
467
468#[derive(Debug, Clone, Default, Deserialize, Serialize)]
469#[serde(rename_all = "camelCase")]
470pub struct ComponentDetailsDto {}
471
472#[derive(Debug, Clone, Default, Deserialize, Serialize)]
473#[serde(rename_all = "camelCase")]
474pub struct ComponentDifferenceDto {
475    #[serde(rename = "componentId")]
476    pub component_id: Option<String>,
477    #[serde(rename = "componentName")]
478    pub component_name: Option<String>,
479    #[serde(rename = "componentType")]
480    pub component_type: Option<String>,
481    pub differences: Option<Vec<DifferenceDto>>,
482    #[serde(rename = "processGroupId")]
483    pub process_group_id: Option<String>,
484}
485
486#[derive(Debug, Clone, Default, Deserialize, Serialize)]
487#[serde(rename_all = "camelCase")]
488pub struct ComponentHistoryDto {
489    #[serde(rename = "componentId")]
490    pub component_id: Option<String>,
491    #[serde(rename = "propertyHistory")]
492    pub property_history: Option<std::collections::HashMap<String, Option<PropertyHistoryDto>>>,
493}
494
495#[derive(Debug, Clone, Default, Deserialize, Serialize)]
496#[serde(rename_all = "camelCase")]
497pub(crate) struct ComponentHistoryEntity {
498    pub component_history: Option<ComponentHistoryDto>,
499}
500
501#[derive(Debug, Clone, Default, Deserialize, Serialize)]
502#[serde(rename_all = "camelCase")]
503pub struct ComponentManifest {
504    pub apis: Option<Vec<DefinedType>>,
505    #[serde(rename = "controllerServices")]
506    pub controller_services: Option<Vec<ControllerServiceDefinition>>,
507    #[serde(rename = "flowAnalysisRules")]
508    pub flow_analysis_rules: Option<Vec<FlowAnalysisRuleDefinition>>,
509    #[serde(rename = "flowRegistryClients")]
510    pub flow_registry_clients: Option<Vec<FlowRegistryClientDefinition>>,
511    #[serde(rename = "parameterProviders")]
512    pub parameter_providers: Option<Vec<ParameterProviderDefinition>>,
513    pub processors: Option<Vec<ProcessorDefinition>>,
514    #[serde(rename = "reportingTasks")]
515    pub reporting_tasks: Option<Vec<ReportingTaskDefinition>>,
516}
517
518#[derive(Debug, Clone, Default, Deserialize, Serialize)]
519#[serde(rename_all = "camelCase")]
520pub struct ComponentReferenceDto {
521    pub id: Option<String>,
522    pub name: Option<String>,
523    #[serde(rename = "parentGroupId")]
524    pub parent_group_id: Option<String>,
525    pub position: Option<PositionDto>,
526    #[serde(rename = "versionedComponentId")]
527    pub versioned_component_id: Option<String>,
528}
529
530#[derive(Debug, Clone, Default, Deserialize, Serialize)]
531#[serde(rename_all = "camelCase")]
532pub struct ComponentReferenceEntity {
533    pub bulletins: Option<Vec<BulletinEntity>>,
534    pub component: Option<ComponentReferenceDto>,
535    #[serde(rename = "disconnectedNodeAcknowledged")]
536    pub disconnected_node_acknowledged: Option<bool>,
537    pub id: Option<String>,
538    #[serde(rename = "parentGroupId")]
539    pub parent_group_id: Option<String>,
540    pub permissions: Option<PermissionsDto>,
541    pub position: Option<PositionDto>,
542    pub revision: Option<RevisionDto>,
543    pub uri: Option<String>,
544}
545
546#[derive(Debug, Clone, Default, Deserialize, Serialize)]
547#[serde(rename_all = "camelCase")]
548pub struct ComponentRestrictionPermissionDto {
549    pub permissions: Option<PermissionsDto>,
550    #[serde(rename = "requiredPermission")]
551    pub required_permission: Option<RequiredPermissionDto>,
552}
553
554#[derive(Debug, Clone, Default, Deserialize, Serialize)]
555#[serde(rename_all = "camelCase")]
556pub struct ComponentSearchResultDto {
557    #[serde(rename = "groupId")]
558    pub group_id: Option<String>,
559    pub id: Option<String>,
560    pub matches: Option<Vec<String>>,
561    pub name: Option<String>,
562    #[serde(rename = "parentGroup")]
563    pub parent_group: Option<SearchResultGroupDto>,
564    #[serde(rename = "versionedGroup")]
565    pub versioned_group: Option<SearchResultGroupDto>,
566}
567
568#[derive(Debug, Clone, Default, Deserialize, Serialize)]
569#[serde(rename_all = "camelCase")]
570pub struct ComponentStateDto {
571    #[serde(rename = "clusterState")]
572    pub cluster_state: Option<StateMapDto>,
573    #[serde(rename = "componentId")]
574    pub component_id: Option<String>,
575    #[serde(rename = "dropStateKeySupported")]
576    pub drop_state_key_supported: Option<bool>,
577    #[serde(rename = "localState")]
578    pub local_state: Option<StateMapDto>,
579    #[serde(rename = "stateDescription")]
580    pub state_description: Option<String>,
581}
582
583#[derive(Debug, Clone, Default, Deserialize, Serialize)]
584#[serde(rename_all = "camelCase")]
585pub(crate) struct ComponentStateEntity {
586    pub component_state: Option<ComponentStateDto>,
587}
588
589#[derive(Debug, Clone, Default, Deserialize, Serialize)]
590#[serde(rename_all = "camelCase")]
591pub struct ComponentValidationResultDto {
592    #[serde(rename = "activeThreadCount")]
593    pub active_thread_count: Option<i32>,
594    #[serde(rename = "currentlyValid")]
595    pub currently_valid: Option<bool>,
596    pub id: Option<String>,
597    pub name: Option<String>,
598    #[serde(rename = "processGroupId")]
599    pub process_group_id: Option<String>,
600    #[serde(rename = "referenceType")]
601    pub reference_type: Option<String>,
602    #[serde(rename = "resultantValidationErrors")]
603    pub resultant_validation_errors: Option<Vec<String>>,
604    #[serde(rename = "resultsValid")]
605    pub results_valid: Option<bool>,
606    pub state: Option<String>,
607    #[serde(rename = "validationErrors")]
608    pub validation_errors: Option<Vec<String>>,
609}
610
611#[derive(Debug, Clone, Default, Deserialize, Serialize)]
612#[serde(rename_all = "camelCase")]
613pub struct ComponentValidationResultEntity {
614    pub bulletins: Option<Vec<BulletinEntity>>,
615    pub component: Option<ComponentValidationResultDto>,
616    #[serde(rename = "disconnectedNodeAcknowledged")]
617    pub disconnected_node_acknowledged: Option<bool>,
618    pub id: Option<String>,
619    pub permissions: Option<PermissionsDto>,
620    pub position: Option<PositionDto>,
621    pub revision: Option<RevisionDto>,
622    pub uri: Option<String>,
623}
624
625#[derive(Debug, Clone, Default, Deserialize, Serialize)]
626#[serde(rename_all = "camelCase")]
627pub struct ComponentValidationResultsEntity {
628    #[serde(rename = "validationResults")]
629    pub validation_results: Option<Vec<ComponentValidationResultEntity>>,
630}
631
632#[derive(Debug, Clone, Default, Deserialize, Serialize)]
633#[serde(rename_all = "camelCase")]
634pub struct ConfigVerificationResultDto {
635    pub explanation: Option<String>,
636    pub outcome: Option<String>,
637    #[serde(rename = "verificationStepName")]
638    pub verification_step_name: Option<String>,
639}
640
641#[derive(Debug, Clone, Default, Deserialize, Serialize)]
642#[serde(rename_all = "camelCase")]
643pub struct ConfigurationAnalysisDto {
644    #[serde(rename = "componentId")]
645    pub component_id: Option<String>,
646    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
647    #[serde(rename = "referencedAttributes")]
648    pub referenced_attributes: Option<std::collections::HashMap<String, Option<String>>>,
649    #[serde(rename = "supportsVerification")]
650    pub supports_verification: Option<bool>,
651}
652
653#[derive(Debug, Clone, Default, Deserialize, Serialize)]
654#[serde(rename_all = "camelCase")]
655pub(crate) struct ConfigurationAnalysisEntity {
656    pub configuration_analysis: Option<ConfigurationAnalysisDto>,
657}
658
659#[derive(Debug, Clone, Default, Deserialize, Serialize)]
660#[serde(rename_all = "camelCase")]
661pub struct ConnectableComponent {
662    pub comments: Option<String>,
663    #[serde(rename = "groupId")]
664    pub group_id: Option<String>,
665    pub id: Option<String>,
666    #[serde(rename = "instanceIdentifier")]
667    pub instance_identifier: Option<String>,
668    pub name: Option<String>,
669    pub r#type: Option<String>,
670}
671
672#[derive(Debug, Clone, Default, Deserialize, Serialize)]
673#[serde(rename_all = "camelCase")]
674pub struct ConnectableDto {
675    pub comments: Option<String>,
676    pub exists: Option<bool>,
677    #[serde(rename = "groupId")]
678    pub group_id: Option<String>,
679    pub id: Option<String>,
680    pub name: Option<String>,
681    pub running: Option<bool>,
682    pub transmitting: Option<bool>,
683    pub r#type: Option<String>,
684    #[serde(rename = "versionedComponentId")]
685    pub versioned_component_id: Option<String>,
686}
687
688#[derive(Debug, Clone, Default, Deserialize, Serialize)]
689#[serde(rename_all = "camelCase")]
690pub struct ConnectionDto {
691    #[serde(rename = "availableRelationships")]
692    pub available_relationships: Option<Vec<String>>,
693    #[serde(rename = "backPressureDataSizeThreshold")]
694    pub back_pressure_data_size_threshold: Option<String>,
695    #[serde(rename = "backPressureObjectThreshold")]
696    pub back_pressure_object_threshold: Option<i64>,
697    pub bends: Option<Vec<PositionDto>>,
698    pub destination: Option<ConnectableDto>,
699    #[serde(rename = "flowFileExpiration")]
700    pub flow_file_expiration: Option<String>,
701    #[serde(rename = "getzIndex")]
702    pub getz_index: Option<i64>,
703    pub id: Option<String>,
704    #[serde(rename = "labelIndex")]
705    pub label_index: Option<i32>,
706    #[serde(rename = "loadBalanceCompression")]
707    pub load_balance_compression: Option<String>,
708    #[serde(rename = "loadBalancePartitionAttribute")]
709    pub load_balance_partition_attribute: Option<String>,
710    #[serde(rename = "loadBalanceStatus")]
711    pub load_balance_status: Option<String>,
712    #[serde(rename = "loadBalanceStrategy")]
713    pub load_balance_strategy: Option<String>,
714    pub name: Option<String>,
715    #[serde(rename = "parentGroupId")]
716    pub parent_group_id: Option<String>,
717    pub position: Option<PositionDto>,
718    pub prioritizers: Option<Vec<String>>,
719    #[serde(rename = "retriedRelationships")]
720    pub retried_relationships: Option<Vec<String>>,
721    #[serde(rename = "selectedRelationships")]
722    pub selected_relationships: Option<Vec<String>>,
723    pub source: Option<ConnectableDto>,
724    #[serde(rename = "versionedComponentId")]
725    pub versioned_component_id: Option<String>,
726}
727
728#[derive(Debug, Clone, Default, Deserialize, Serialize)]
729#[serde(rename_all = "camelCase")]
730pub struct ConnectionEntity {
731    pub bends: Option<Vec<PositionDto>>,
732    pub bulletins: Option<Vec<BulletinEntity>>,
733    pub component: Option<ConnectionDto>,
734    #[serde(rename = "destinationGroupId")]
735    pub destination_group_id: Option<String>,
736    #[serde(rename = "destinationId")]
737    pub destination_id: Option<String>,
738    #[serde(rename = "destinationType")]
739    pub destination_type: Option<String>,
740    #[serde(rename = "disconnectedNodeAcknowledged")]
741    pub disconnected_node_acknowledged: Option<bool>,
742    #[serde(rename = "getzIndex")]
743    pub getz_index: Option<i64>,
744    pub id: Option<String>,
745    #[serde(rename = "labelIndex")]
746    pub label_index: Option<i32>,
747    pub permissions: Option<PermissionsDto>,
748    pub position: Option<PositionDto>,
749    pub revision: Option<RevisionDto>,
750    #[serde(rename = "sourceGroupId")]
751    pub source_group_id: Option<String>,
752    #[serde(rename = "sourceId")]
753    pub source_id: Option<String>,
754    #[serde(rename = "sourceType")]
755    pub source_type: Option<String>,
756    pub status: Option<ConnectionStatusDto>,
757    pub uri: Option<String>,
758}
759
760#[derive(Debug, Clone, Default, Deserialize, Serialize)]
761#[serde(rename_all = "camelCase")]
762pub struct ConnectionStatisticsDto {
763    #[serde(rename = "aggregateSnapshot")]
764    pub aggregate_snapshot: Option<ConnectionStatisticsSnapshotDto>,
765    pub id: Option<String>,
766    #[serde(rename = "nodeSnapshots")]
767    pub node_snapshots: Option<Vec<NodeConnectionStatisticsSnapshotDto>>,
768    #[serde(rename = "statsLastRefreshed")]
769    pub stats_last_refreshed: Option<String>,
770}
771
772#[derive(Debug, Clone, Default, Deserialize, Serialize)]
773#[serde(rename_all = "camelCase")]
774pub struct ConnectionStatisticsEntity {
775    #[serde(rename = "canRead")]
776    pub can_read: Option<bool>,
777    #[serde(rename = "connectionStatistics")]
778    pub connection_statistics: Option<ConnectionStatisticsDto>,
779}
780
781#[derive(Debug, Clone, Default, Deserialize, Serialize)]
782#[serde(rename_all = "camelCase")]
783pub struct ConnectionStatisticsSnapshotDto {
784    pub id: Option<String>,
785    #[serde(rename = "predictedBytesAtNextInterval")]
786    pub predicted_bytes_at_next_interval: Option<i64>,
787    #[serde(rename = "predictedCountAtNextInterval")]
788    pub predicted_count_at_next_interval: Option<i32>,
789    #[serde(rename = "predictedMillisUntilBytesBackpressure")]
790    pub predicted_millis_until_bytes_backpressure: Option<i64>,
791    #[serde(rename = "predictedMillisUntilCountBackpressure")]
792    pub predicted_millis_until_count_backpressure: Option<i64>,
793    #[serde(rename = "predictedPercentBytes")]
794    pub predicted_percent_bytes: Option<i32>,
795    #[serde(rename = "predictedPercentCount")]
796    pub predicted_percent_count: Option<i32>,
797    #[serde(rename = "predictionIntervalMillis")]
798    pub prediction_interval_millis: Option<i64>,
799}
800
801#[derive(Debug, Clone, Default, Deserialize, Serialize)]
802#[serde(rename_all = "camelCase")]
803pub struct ConnectionStatusDto {
804    #[serde(rename = "aggregateSnapshot")]
805    pub aggregate_snapshot: Option<ConnectionStatusSnapshotDto>,
806    #[serde(rename = "destinationId")]
807    pub destination_id: Option<String>,
808    #[serde(rename = "destinationName")]
809    pub destination_name: Option<String>,
810    #[serde(rename = "groupId")]
811    pub group_id: Option<String>,
812    pub id: Option<String>,
813    pub name: Option<String>,
814    #[serde(rename = "nodeSnapshots")]
815    pub node_snapshots: Option<Vec<NodeConnectionStatusSnapshotDto>>,
816    #[serde(rename = "sourceId")]
817    pub source_id: Option<String>,
818    #[serde(rename = "sourceName")]
819    pub source_name: Option<String>,
820    #[serde(rename = "statsLastRefreshed")]
821    pub stats_last_refreshed: Option<String>,
822}
823
824#[derive(Debug, Clone, Default, Deserialize, Serialize)]
825#[serde(rename_all = "camelCase")]
826pub struct ConnectionStatusEntity {
827    #[serde(rename = "canRead")]
828    pub can_read: Option<bool>,
829    #[serde(rename = "connectionStatus")]
830    pub connection_status: Option<ConnectionStatusDto>,
831}
832
833#[derive(Debug, Clone, Default, Deserialize, Serialize)]
834#[serde(rename_all = "camelCase")]
835pub struct ConnectionStatusPredictionsSnapshotDto {
836    #[serde(rename = "predictedBytesAtNextInterval")]
837    pub predicted_bytes_at_next_interval: Option<i64>,
838    #[serde(rename = "predictedCountAtNextInterval")]
839    pub predicted_count_at_next_interval: Option<i32>,
840    #[serde(rename = "predictedMillisUntilBytesBackpressure")]
841    pub predicted_millis_until_bytes_backpressure: Option<i64>,
842    #[serde(rename = "predictedMillisUntilCountBackpressure")]
843    pub predicted_millis_until_count_backpressure: Option<i64>,
844    #[serde(rename = "predictedPercentBytes")]
845    pub predicted_percent_bytes: Option<i32>,
846    #[serde(rename = "predictedPercentCount")]
847    pub predicted_percent_count: Option<i32>,
848    #[serde(rename = "predictionIntervalSeconds")]
849    pub prediction_interval_seconds: Option<i32>,
850}
851
852#[derive(Debug, Clone, Default, Deserialize, Serialize)]
853#[serde(rename_all = "camelCase")]
854pub struct ConnectionStatusSnapshotDto {
855    #[serde(rename = "bytesIn")]
856    pub bytes_in: Option<i64>,
857    #[serde(rename = "bytesOut")]
858    pub bytes_out: Option<i64>,
859    #[serde(rename = "bytesQueued")]
860    pub bytes_queued: Option<i64>,
861    #[serde(rename = "destinationId")]
862    pub destination_id: Option<String>,
863    #[serde(rename = "destinationName")]
864    pub destination_name: Option<String>,
865    #[serde(rename = "flowFileAvailability")]
866    pub flow_file_availability: Option<String>,
867    #[serde(rename = "flowFilesIn")]
868    pub flow_files_in: Option<i32>,
869    #[serde(rename = "flowFilesOut")]
870    pub flow_files_out: Option<i32>,
871    #[serde(rename = "flowFilesQueued")]
872    pub flow_files_queued: Option<i32>,
873    #[serde(rename = "groupId")]
874    pub group_id: Option<String>,
875    pub id: Option<String>,
876    pub input: Option<String>,
877    #[serde(rename = "loadBalanceStatus")]
878    pub load_balance_status: Option<String>,
879    pub name: Option<String>,
880    pub output: Option<String>,
881    #[serde(rename = "percentUseBytes")]
882    pub percent_use_bytes: Option<i32>,
883    #[serde(rename = "percentUseCount")]
884    pub percent_use_count: Option<i32>,
885    pub predictions: Option<ConnectionStatusPredictionsSnapshotDto>,
886    pub queued: Option<String>,
887    #[serde(rename = "queuedCount")]
888    pub queued_count: Option<String>,
889    #[serde(rename = "queuedSize")]
890    pub queued_size: Option<String>,
891    #[serde(rename = "sourceId")]
892    pub source_id: Option<String>,
893    #[serde(rename = "sourceName")]
894    pub source_name: Option<String>,
895}
896
897#[derive(Debug, Clone, Default, Deserialize, Serialize)]
898#[serde(rename_all = "camelCase")]
899pub struct ConnectionStatusSnapshotEntity {
900    #[serde(rename = "canRead")]
901    pub can_read: Option<bool>,
902    #[serde(rename = "connectionStatusSnapshot")]
903    pub connection_status_snapshot: Option<ConnectionStatusSnapshotDto>,
904    pub id: Option<String>,
905}
906
907#[derive(Debug, Clone, Default, Deserialize, Serialize)]
908#[serde(rename_all = "camelCase")]
909pub struct ConnectionsEntity {
910    pub connections: Option<Vec<ConnectionEntity>>,
911}
912
913#[derive(Debug, Clone, Default, Deserialize, Serialize)]
914#[serde(rename_all = "camelCase")]
915pub struct ContentViewerDto {
916    #[serde(rename = "displayName")]
917    pub display_name: Option<String>,
918    #[serde(rename = "supportedMimeTypes")]
919    pub supported_mime_types: Option<Vec<SupportedMimeTypesDto>>,
920    pub uri: Option<String>,
921}
922
923#[derive(Debug, Clone, Default, Deserialize, Serialize)]
924#[serde(rename_all = "camelCase")]
925pub struct ContentViewerEntity {
926    #[serde(rename = "contentViewers")]
927    pub content_viewers: Option<Vec<ContentViewerDto>>,
928}
929
930#[derive(Debug, Clone, Default, Deserialize, Serialize)]
931#[serde(rename_all = "camelCase")]
932pub struct ControllerBulletinsEntity {
933    pub bulletins: Option<Vec<BulletinEntity>>,
934    #[serde(rename = "controllerServiceBulletins")]
935    pub controller_service_bulletins: Option<Vec<BulletinEntity>>,
936    #[serde(rename = "flowAnalysisRuleBulletins")]
937    pub flow_analysis_rule_bulletins: Option<Vec<BulletinEntity>>,
938    #[serde(rename = "flowRegistryClientBulletins")]
939    pub flow_registry_client_bulletins: Option<Vec<BulletinEntity>>,
940    #[serde(rename = "parameterProviderBulletins")]
941    pub parameter_provider_bulletins: Option<Vec<BulletinEntity>>,
942    #[serde(rename = "reportingTaskBulletins")]
943    pub reporting_task_bulletins: Option<Vec<BulletinEntity>>,
944}
945
946#[derive(Debug, Clone, Default, Deserialize, Serialize)]
947#[serde(rename_all = "camelCase")]
948pub struct ControllerConfigurationDto {
949    #[serde(rename = "maxTimerDrivenThreadCount")]
950    pub max_timer_driven_thread_count: Option<i32>,
951}
952
953#[derive(Debug, Clone, Default, Deserialize, Serialize)]
954#[serde(rename_all = "camelCase")]
955pub struct ControllerConfigurationEntity {
956    pub component: Option<ControllerConfigurationDto>,
957    #[serde(rename = "disconnectedNodeAcknowledged")]
958    pub disconnected_node_acknowledged: Option<bool>,
959    pub permissions: Option<PermissionsDto>,
960    pub revision: Option<RevisionDto>,
961}
962
963#[derive(Debug, Clone, Default, Deserialize, Serialize)]
964#[serde(rename_all = "camelCase")]
965pub struct ControllerDto {
966    #[serde(rename = "activeRemotePortCount")]
967    pub active_remote_port_count: Option<i32>,
968    pub comments: Option<String>,
969    #[serde(rename = "disabledCount")]
970    pub disabled_count: Option<i32>,
971    pub id: Option<String>,
972    #[serde(rename = "inactiveRemotePortCount")]
973    pub inactive_remote_port_count: Option<i32>,
974    #[serde(rename = "inputPortCount")]
975    pub input_port_count: Option<i32>,
976    #[serde(rename = "inputPorts")]
977    pub input_ports: Option<Vec<PortDto>>,
978    #[serde(rename = "instanceId")]
979    pub instance_id: Option<String>,
980    #[serde(rename = "invalidCount")]
981    pub invalid_count: Option<i32>,
982    pub name: Option<String>,
983    #[serde(rename = "outputPortCount")]
984    pub output_port_count: Option<i32>,
985    #[serde(rename = "outputPorts")]
986    pub output_ports: Option<Vec<PortDto>>,
987    #[serde(rename = "remoteSiteHttpListeningPort")]
988    pub remote_site_http_listening_port: Option<i32>,
989    #[serde(rename = "remoteSiteListeningPort")]
990    pub remote_site_listening_port: Option<i32>,
991    #[serde(rename = "runningCount")]
992    pub running_count: Option<i32>,
993    #[serde(rename = "siteToSiteSecure")]
994    pub site_to_site_secure: Option<bool>,
995    #[serde(rename = "stoppedCount")]
996    pub stopped_count: Option<i32>,
997}
998
999#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1000#[serde(rename_all = "camelCase")]
1001pub(crate) struct ControllerEntity {
1002    pub controller: Option<ControllerDto>,
1003}
1004
1005#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1006#[serde(rename_all = "camelCase")]
1007pub struct ControllerServiceAPI {
1008    pub bundle: Option<Bundle>,
1009    pub r#type: Option<String>,
1010}
1011
1012#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1013#[serde(rename_all = "camelCase")]
1014pub struct ControllerServiceApiDto {
1015    pub bundle: Option<BundleDto>,
1016    pub r#type: Option<String>,
1017}
1018
1019#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1020#[serde(rename_all = "camelCase")]
1021pub struct ControllerServiceDefinition {
1022    #[serde(rename = "additionalDetails")]
1023    pub additional_details: Option<bool>,
1024    pub artifact: Option<String>,
1025    #[serde(rename = "buildInfo")]
1026    pub build_info: Option<BuildInfo>,
1027    pub deprecated: Option<bool>,
1028    #[serde(rename = "deprecationAlternatives")]
1029    pub deprecation_alternatives: Option<Vec<String>>,
1030    #[serde(rename = "deprecationReason")]
1031    pub deprecation_reason: Option<String>,
1032    #[serde(rename = "dynamicProperties")]
1033    pub dynamic_properties: Option<Vec<DynamicProperty>>,
1034    #[serde(rename = "explicitRestrictions")]
1035    pub explicit_restrictions: Option<Vec<Restriction>>,
1036    pub group: Option<String>,
1037    #[serde(rename = "propertyDescriptors")]
1038    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
1039    #[serde(rename = "providedApiImplementations")]
1040    pub provided_api_implementations: Option<Vec<DefinedType>>,
1041    pub restricted: Option<bool>,
1042    #[serde(rename = "restrictedExplanation")]
1043    pub restricted_explanation: Option<String>,
1044    #[serde(rename = "seeAlso")]
1045    pub see_also: Option<Vec<String>>,
1046    pub stateful: Option<Stateful>,
1047    #[serde(rename = "supportsDynamicProperties")]
1048    pub supports_dynamic_properties: Option<bool>,
1049    #[serde(rename = "supportsSensitiveDynamicProperties")]
1050    pub supports_sensitive_dynamic_properties: Option<bool>,
1051    #[serde(rename = "systemResourceConsiderations")]
1052    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
1053    pub tags: Option<Vec<String>>,
1054    pub r#type: Option<String>,
1055    #[serde(rename = "typeDescription")]
1056    pub type_description: Option<String>,
1057    pub version: Option<String>,
1058}
1059
1060#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1061#[serde(rename_all = "camelCase")]
1062pub struct ControllerServiceDto {
1063    #[serde(rename = "annotationData")]
1064    pub annotation_data: Option<String>,
1065    #[serde(rename = "bulletinLevel")]
1066    pub bulletin_level: Option<String>,
1067    pub bundle: Option<BundleDto>,
1068    pub comments: Option<String>,
1069    #[serde(rename = "controllerServiceApis")]
1070    pub controller_service_apis: Option<Vec<ControllerServiceApiDto>>,
1071    #[serde(rename = "customUiUrl")]
1072    pub custom_ui_url: Option<String>,
1073    pub deprecated: Option<bool>,
1074    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
1075    #[serde(rename = "extensionMissing")]
1076    pub extension_missing: Option<bool>,
1077    pub id: Option<String>,
1078    #[serde(rename = "multipleVersionsAvailable")]
1079    pub multiple_versions_available: Option<bool>,
1080    pub name: Option<String>,
1081    #[serde(rename = "parentGroupId")]
1082    pub parent_group_id: Option<String>,
1083    #[serde(rename = "persistsState")]
1084    pub persists_state: Option<bool>,
1085    pub position: Option<PositionDto>,
1086    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
1087    #[serde(rename = "referencingComponents")]
1088    pub referencing_components: Option<Vec<ControllerServiceReferencingComponentEntity>>,
1089    pub restricted: Option<bool>,
1090    #[serde(rename = "sensitiveDynamicPropertyNames")]
1091    pub sensitive_dynamic_property_names: Option<Vec<String>>,
1092    pub state: Option<String>,
1093    #[serde(rename = "supportsSensitiveDynamicProperties")]
1094    pub supports_sensitive_dynamic_properties: Option<bool>,
1095    pub r#type: Option<String>,
1096    #[serde(rename = "validationErrors")]
1097    pub validation_errors: Option<Vec<String>>,
1098    #[serde(rename = "validationStatus")]
1099    pub validation_status: Option<String>,
1100    #[serde(rename = "versionedComponentId")]
1101    pub versioned_component_id: Option<String>,
1102}
1103
1104#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1105#[serde(rename_all = "camelCase")]
1106pub struct ControllerServiceEntity {
1107    pub bulletins: Option<Vec<BulletinEntity>>,
1108    pub component: Option<ControllerServiceDto>,
1109    #[serde(rename = "disconnectedNodeAcknowledged")]
1110    pub disconnected_node_acknowledged: Option<bool>,
1111    pub id: Option<String>,
1112    #[serde(rename = "operatePermissions")]
1113    pub operate_permissions: Option<PermissionsDto>,
1114    #[serde(rename = "parentGroupId")]
1115    pub parent_group_id: Option<String>,
1116    pub permissions: Option<PermissionsDto>,
1117    pub position: Option<PositionDto>,
1118    pub revision: Option<RevisionDto>,
1119    pub status: Option<ControllerServiceStatusDto>,
1120    pub uri: Option<String>,
1121}
1122
1123#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1124#[serde(rename_all = "camelCase")]
1125pub struct ControllerServiceReferencingComponentDto {
1126    #[serde(rename = "activeThreadCount")]
1127    pub active_thread_count: Option<i32>,
1128    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
1129    #[serde(rename = "groupId")]
1130    pub group_id: Option<String>,
1131    pub id: Option<String>,
1132    pub name: Option<String>,
1133    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
1134    #[serde(rename = "referenceCycle")]
1135    pub reference_cycle: Option<bool>,
1136    #[serde(rename = "referenceType")]
1137    pub reference_type: Option<String>,
1138    #[serde(rename = "referencingComponents")]
1139    pub referencing_components: Option<Vec<ControllerServiceReferencingComponentEntity>>,
1140    pub state: Option<String>,
1141    pub r#type: Option<String>,
1142    #[serde(rename = "validationErrors")]
1143    pub validation_errors: Option<Vec<String>>,
1144}
1145
1146#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1147#[serde(rename_all = "camelCase")]
1148pub struct ControllerServiceReferencingComponentEntity {
1149    pub bulletins: Option<Vec<BulletinEntity>>,
1150    pub component: Option<ControllerServiceReferencingComponentDto>,
1151    #[serde(rename = "disconnectedNodeAcknowledged")]
1152    pub disconnected_node_acknowledged: Option<bool>,
1153    pub id: Option<String>,
1154    #[serde(rename = "operatePermissions")]
1155    pub operate_permissions: Option<PermissionsDto>,
1156    pub permissions: Option<PermissionsDto>,
1157    pub position: Option<PositionDto>,
1158    pub revision: Option<RevisionDto>,
1159    pub uri: Option<String>,
1160}
1161
1162#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1163#[serde(rename_all = "camelCase")]
1164pub struct ControllerServiceReferencingComponentsEntity {
1165    #[serde(rename = "controllerServiceReferencingComponents")]
1166    pub controller_service_referencing_components:
1167        Option<Vec<ControllerServiceReferencingComponentEntity>>,
1168}
1169
1170#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1171#[serde(rename_all = "camelCase")]
1172pub struct ControllerServiceRunStatusEntity {
1173    #[serde(rename = "disconnectedNodeAcknowledged")]
1174    pub disconnected_node_acknowledged: Option<bool>,
1175    pub revision: Option<RevisionDto>,
1176    pub state: Option<String>,
1177    #[serde(rename = "uiOnly")]
1178    pub ui_only: Option<bool>,
1179}
1180
1181#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1182#[serde(rename_all = "camelCase")]
1183pub struct ControllerServiceStatusDto {
1184    #[serde(rename = "activeThreadCount")]
1185    pub active_thread_count: Option<i32>,
1186    #[serde(rename = "runStatus")]
1187    pub run_status: Option<String>,
1188    #[serde(rename = "validationStatus")]
1189    pub validation_status: Option<String>,
1190}
1191
1192#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1193#[serde(rename_all = "camelCase")]
1194pub struct ControllerServiceTypesEntity {
1195    #[serde(rename = "controllerServiceTypes")]
1196    pub controller_service_types: Option<Vec<DocumentedTypeDto>>,
1197}
1198
1199#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1200#[serde(rename_all = "camelCase")]
1201pub struct ControllerServicesEntity {
1202    #[serde(rename = "controllerServices")]
1203    pub controller_services: Option<Vec<ControllerServiceEntity>>,
1204    #[serde(rename = "currentTime")]
1205    pub current_time: Option<String>,
1206}
1207
1208#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1209#[serde(rename_all = "camelCase")]
1210pub struct ControllerStatusDto {
1211    #[serde(rename = "activeRemotePortCount")]
1212    pub active_remote_port_count: Option<i32>,
1213    #[serde(rename = "activeThreadCount")]
1214    pub active_thread_count: Option<i32>,
1215    #[serde(rename = "bytesQueued")]
1216    pub bytes_queued: Option<i64>,
1217    #[serde(rename = "disabledCount")]
1218    pub disabled_count: Option<i32>,
1219    #[serde(rename = "flowFilesQueued")]
1220    pub flow_files_queued: Option<i32>,
1221    #[serde(rename = "inactiveRemotePortCount")]
1222    pub inactive_remote_port_count: Option<i32>,
1223    #[serde(rename = "invalidCount")]
1224    pub invalid_count: Option<i32>,
1225    #[serde(rename = "locallyModifiedAndStaleCount")]
1226    pub locally_modified_and_stale_count: Option<i32>,
1227    #[serde(rename = "locallyModifiedCount")]
1228    pub locally_modified_count: Option<i32>,
1229    pub queued: Option<String>,
1230    #[serde(rename = "runningCount")]
1231    pub running_count: Option<i32>,
1232    #[serde(rename = "staleCount")]
1233    pub stale_count: Option<i32>,
1234    #[serde(rename = "stoppedCount")]
1235    pub stopped_count: Option<i32>,
1236    #[serde(rename = "syncFailureCount")]
1237    pub sync_failure_count: Option<i32>,
1238    #[serde(rename = "terminatedThreadCount")]
1239    pub terminated_thread_count: Option<i32>,
1240    #[serde(rename = "upToDateCount")]
1241    pub up_to_date_count: Option<i32>,
1242}
1243
1244#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1245#[serde(rename_all = "camelCase")]
1246pub(crate) struct ControllerStatusEntity {
1247    pub controller_status: Option<ControllerStatusDto>,
1248}
1249
1250#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1251#[serde(rename_all = "camelCase")]
1252pub struct CopyRequestEntity {
1253    pub connections: Option<Vec<String>>,
1254    pub funnels: Option<Vec<String>>,
1255    #[serde(rename = "inputPorts")]
1256    pub input_ports: Option<Vec<String>>,
1257    pub labels: Option<Vec<String>>,
1258    #[serde(rename = "outputPorts")]
1259    pub output_ports: Option<Vec<String>>,
1260    #[serde(rename = "processGroups")]
1261    pub process_groups: Option<Vec<String>>,
1262    pub processors: Option<Vec<String>>,
1263    #[serde(rename = "remoteProcessGroups")]
1264    pub remote_process_groups: Option<Vec<String>>,
1265}
1266
1267#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1268#[serde(rename_all = "camelCase")]
1269pub struct CopyResponseEntity {
1270    pub connections: Option<Vec<VersionedConnection>>,
1271    #[serde(rename = "externalControllerServiceReferences")]
1272    pub external_controller_service_references:
1273        Option<std::collections::HashMap<String, Option<ExternalControllerServiceReference>>>,
1274    pub funnels: Option<Vec<VersionedFunnel>>,
1275    pub id: Option<String>,
1276    #[serde(rename = "inputPorts")]
1277    pub input_ports: Option<Vec<VersionedPort>>,
1278    pub labels: Option<Vec<VersionedLabel>>,
1279    #[serde(rename = "outputPorts")]
1280    pub output_ports: Option<Vec<VersionedPort>>,
1281    #[serde(rename = "parameterContexts")]
1282    pub parameter_contexts:
1283        Option<std::collections::HashMap<String, Option<VersionedParameterContext>>>,
1284    #[serde(rename = "parameterProviders")]
1285    pub parameter_providers:
1286        Option<std::collections::HashMap<String, Option<ParameterProviderReference>>>,
1287    #[serde(rename = "processGroups")]
1288    pub process_groups: Option<Vec<VersionedProcessGroup>>,
1289    pub processors: Option<Vec<VersionedProcessor>>,
1290    #[serde(rename = "remoteProcessGroups")]
1291    pub remote_process_groups: Option<Vec<VersionedRemoteProcessGroup>>,
1292}
1293
1294#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1295#[serde(rename_all = "camelCase")]
1296pub struct CopySnippetRequestEntity {
1297    #[serde(rename = "disconnectedNodeAcknowledged")]
1298    pub disconnected_node_acknowledged: Option<bool>,
1299    #[serde(rename = "originX")]
1300    pub origin_x: Option<f64>,
1301    #[serde(rename = "originY")]
1302    pub origin_y: Option<f64>,
1303    #[serde(rename = "snippetId")]
1304    pub snippet_id: Option<String>,
1305}
1306
1307#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1308#[serde(rename_all = "camelCase")]
1309pub struct CounterDto {
1310    pub context: Option<String>,
1311    pub id: Option<String>,
1312    pub name: Option<String>,
1313    pub value: Option<String>,
1314    #[serde(rename = "valueCount")]
1315    pub value_count: Option<i64>,
1316}
1317
1318#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1319#[serde(rename_all = "camelCase")]
1320pub(crate) struct CounterEntity {
1321    pub counter: Option<CounterDto>,
1322}
1323
1324#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1325#[serde(rename_all = "camelCase")]
1326pub struct CountersDto {
1327    #[serde(rename = "aggregateSnapshot")]
1328    pub aggregate_snapshot: Option<CountersSnapshotDto>,
1329    #[serde(rename = "nodeSnapshots")]
1330    pub node_snapshots: Option<Vec<NodeCountersSnapshotDto>>,
1331}
1332
1333#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1334#[serde(rename_all = "camelCase")]
1335pub(crate) struct CountersEntity {
1336    pub counters: Option<CountersDto>,
1337}
1338
1339#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1340#[serde(rename_all = "camelCase")]
1341pub struct CountersSnapshotDto {
1342    pub counters: Option<Vec<CounterDto>>,
1343    pub generated: Option<String>,
1344}
1345
1346#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1347#[serde(rename_all = "camelCase")]
1348pub struct CreateActiveRequestEntity {
1349    #[serde(rename = "disconnectedNodeAcknowledged")]
1350    pub disconnected_node_acknowledged: Option<bool>,
1351    #[serde(rename = "processGroupId")]
1352    pub process_group_id: Option<String>,
1353}
1354
1355#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1356#[serde(rename_all = "camelCase")]
1357pub struct CurrentUserEntity {
1358    pub anonymous: Option<bool>,
1359    #[serde(rename = "canVersionFlows")]
1360    pub can_version_flows: Option<bool>,
1361    #[serde(rename = "componentRestrictionPermissions")]
1362    pub component_restriction_permissions: Option<Vec<ComponentRestrictionPermissionDto>>,
1363    #[serde(rename = "controllerPermissions")]
1364    pub controller_permissions: Option<PermissionsDto>,
1365    #[serde(rename = "countersPermissions")]
1366    pub counters_permissions: Option<PermissionsDto>,
1367    pub identity: Option<String>,
1368    #[serde(rename = "logoutSupported")]
1369    pub logout_supported: Option<bool>,
1370    #[serde(rename = "parameterContextPermissions")]
1371    pub parameter_context_permissions: Option<PermissionsDto>,
1372    #[serde(rename = "policiesPermissions")]
1373    pub policies_permissions: Option<PermissionsDto>,
1374    #[serde(rename = "provenancePermissions")]
1375    pub provenance_permissions: Option<PermissionsDto>,
1376    #[serde(rename = "restrictedComponentsPermissions")]
1377    pub restricted_components_permissions: Option<PermissionsDto>,
1378    #[serde(rename = "systemPermissions")]
1379    pub system_permissions: Option<PermissionsDto>,
1380    #[serde(rename = "tenantsPermissions")]
1381    pub tenants_permissions: Option<PermissionsDto>,
1382}
1383
1384#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1385#[serde(rename_all = "camelCase")]
1386pub struct DateTimeParameter {
1387    #[serde(rename = "dateTime")]
1388    pub date_time: Option<String>,
1389}
1390
1391#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1392#[serde(rename_all = "camelCase")]
1393pub struct DefinedType {
1394    pub artifact: Option<String>,
1395    pub group: Option<String>,
1396    pub r#type: Option<String>,
1397    #[serde(rename = "typeDescription")]
1398    pub type_description: Option<String>,
1399    pub version: Option<String>,
1400}
1401
1402#[derive(Debug, Clone, Deserialize, Serialize)]
1403pub enum DiagnosticLevel {
1404    #[serde(rename = "BASIC")]
1405    Basic,
1406    #[serde(rename = "VERBOSE")]
1407    Verbose,
1408}
1409
1410#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1411#[serde(rename_all = "camelCase")]
1412pub struct DifferenceDto {
1413    pub difference: Option<String>,
1414    #[serde(rename = "differenceType")]
1415    pub difference_type: Option<String>,
1416}
1417
1418#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1419#[serde(rename_all = "camelCase")]
1420pub struct DimensionsDto {
1421    pub height: Option<f64>,
1422    pub width: Option<f64>,
1423}
1424
1425#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1426#[serde(rename_all = "camelCase")]
1427pub struct DocumentedTypeDto {
1428    pub bundle: Option<BundleDto>,
1429    #[serde(rename = "controllerServiceApis")]
1430    pub controller_service_apis: Option<Vec<ControllerServiceApiDto>>,
1431    #[serde(rename = "deprecationReason")]
1432    pub deprecation_reason: Option<String>,
1433    pub description: Option<String>,
1434    #[serde(rename = "explicitRestrictions")]
1435    pub explicit_restrictions: Option<Vec<ExplicitRestrictionDto>>,
1436    pub restricted: Option<bool>,
1437    pub tags: Option<Vec<String>>,
1438    pub r#type: Option<String>,
1439    #[serde(rename = "usageRestriction")]
1440    pub usage_restriction: Option<String>,
1441}
1442
1443#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1444#[serde(rename_all = "camelCase")]
1445pub struct DropRequestDto {
1446    pub current: Option<String>,
1447    #[serde(rename = "currentCount")]
1448    pub current_count: Option<i32>,
1449    #[serde(rename = "currentSize")]
1450    pub current_size: Option<i64>,
1451    pub dropped: Option<String>,
1452    #[serde(rename = "droppedCount")]
1453    pub dropped_count: Option<i32>,
1454    #[serde(rename = "droppedSize")]
1455    pub dropped_size: Option<i64>,
1456    #[serde(rename = "failureReason")]
1457    pub failure_reason: Option<String>,
1458    pub finished: Option<bool>,
1459    pub id: Option<String>,
1460    #[serde(rename = "lastUpdated")]
1461    pub last_updated: Option<String>,
1462    pub original: Option<String>,
1463    #[serde(rename = "originalCount")]
1464    pub original_count: Option<i32>,
1465    #[serde(rename = "originalSize")]
1466    pub original_size: Option<i64>,
1467    #[serde(rename = "percentCompleted")]
1468    pub percent_completed: Option<i32>,
1469    pub state: Option<String>,
1470    #[serde(rename = "submissionTime")]
1471    pub submission_time: Option<String>,
1472    pub uri: Option<String>,
1473}
1474
1475#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1476#[serde(rename_all = "camelCase")]
1477pub(crate) struct DropRequestEntity {
1478    pub drop_request: Option<DropRequestDto>,
1479}
1480
1481#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1482#[serde(rename_all = "camelCase")]
1483pub struct DynamicProperty {
1484    pub description: Option<String>,
1485    #[serde(rename = "expressionLanguageScope")]
1486    pub expression_language_scope: Option<String>,
1487    pub name: Option<String>,
1488    pub value: Option<String>,
1489}
1490
1491#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1492#[serde(rename_all = "camelCase")]
1493pub struct DynamicRelationship {
1494    pub description: Option<String>,
1495    pub name: Option<String>,
1496}
1497
1498#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1499#[serde(rename_all = "camelCase")]
1500pub struct ExplicitRestrictionDto {
1501    pub explanation: Option<String>,
1502    #[serde(rename = "requiredPermission")]
1503    pub required_permission: Option<RequiredPermissionDto>,
1504}
1505
1506#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1507#[serde(rename_all = "camelCase")]
1508pub struct ExternalControllerServiceReference {
1509    pub identifier: Option<String>,
1510    pub name: Option<String>,
1511}
1512
1513#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1514#[serde(rename_all = "camelCase")]
1515pub struct FlowAnalysisResultEntity {
1516    #[serde(rename = "flowAnalysisPending")]
1517    pub flow_analysis_pending: Option<bool>,
1518    #[serde(rename = "ruleViolations")]
1519    pub rule_violations: Option<Vec<FlowAnalysisRuleViolationDto>>,
1520    pub rules: Option<Vec<FlowAnalysisRuleDto>>,
1521}
1522
1523#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1524#[serde(rename_all = "camelCase")]
1525pub struct FlowAnalysisRuleDefinition {
1526    #[serde(rename = "additionalDetails")]
1527    pub additional_details: Option<bool>,
1528    pub artifact: Option<String>,
1529    #[serde(rename = "buildInfo")]
1530    pub build_info: Option<BuildInfo>,
1531    pub deprecated: Option<bool>,
1532    #[serde(rename = "deprecationAlternatives")]
1533    pub deprecation_alternatives: Option<Vec<String>>,
1534    #[serde(rename = "deprecationReason")]
1535    pub deprecation_reason: Option<String>,
1536    #[serde(rename = "dynamicProperties")]
1537    pub dynamic_properties: Option<Vec<DynamicProperty>>,
1538    #[serde(rename = "explicitRestrictions")]
1539    pub explicit_restrictions: Option<Vec<Restriction>>,
1540    pub group: Option<String>,
1541    #[serde(rename = "propertyDescriptors")]
1542    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
1543    #[serde(rename = "providedApiImplementations")]
1544    pub provided_api_implementations: Option<Vec<DefinedType>>,
1545    pub restricted: Option<bool>,
1546    #[serde(rename = "restrictedExplanation")]
1547    pub restricted_explanation: Option<String>,
1548    #[serde(rename = "seeAlso")]
1549    pub see_also: Option<Vec<String>>,
1550    pub stateful: Option<Stateful>,
1551    #[serde(rename = "supportsDynamicProperties")]
1552    pub supports_dynamic_properties: Option<bool>,
1553    #[serde(rename = "supportsSensitiveDynamicProperties")]
1554    pub supports_sensitive_dynamic_properties: Option<bool>,
1555    #[serde(rename = "systemResourceConsiderations")]
1556    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
1557    pub tags: Option<Vec<String>>,
1558    pub r#type: Option<String>,
1559    #[serde(rename = "typeDescription")]
1560    pub type_description: Option<String>,
1561    pub version: Option<String>,
1562}
1563
1564#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1565#[serde(rename_all = "camelCase")]
1566pub struct FlowAnalysisRuleDto {
1567    pub bundle: Option<BundleDto>,
1568    pub comments: Option<String>,
1569    pub deprecated: Option<bool>,
1570    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
1571    #[serde(rename = "enforcementPolicy")]
1572    pub enforcement_policy: Option<String>,
1573    #[serde(rename = "extensionMissing")]
1574    pub extension_missing: Option<bool>,
1575    pub id: Option<String>,
1576    #[serde(rename = "multipleVersionsAvailable")]
1577    pub multiple_versions_available: Option<bool>,
1578    pub name: Option<String>,
1579    #[serde(rename = "parentGroupId")]
1580    pub parent_group_id: Option<String>,
1581    #[serde(rename = "persistsState")]
1582    pub persists_state: Option<bool>,
1583    pub position: Option<PositionDto>,
1584    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
1585    pub restricted: Option<bool>,
1586    #[serde(rename = "sensitiveDynamicPropertyNames")]
1587    pub sensitive_dynamic_property_names: Option<Vec<String>>,
1588    pub state: Option<String>,
1589    #[serde(rename = "supportsSensitiveDynamicProperties")]
1590    pub supports_sensitive_dynamic_properties: Option<bool>,
1591    pub r#type: Option<String>,
1592    #[serde(rename = "validationErrors")]
1593    pub validation_errors: Option<Vec<String>>,
1594    #[serde(rename = "validationStatus")]
1595    pub validation_status: Option<String>,
1596    #[serde(rename = "versionedComponentId")]
1597    pub versioned_component_id: Option<String>,
1598}
1599
1600#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1601#[serde(rename_all = "camelCase")]
1602pub struct FlowAnalysisRuleEntity {
1603    pub bulletins: Option<Vec<BulletinEntity>>,
1604    pub component: Option<FlowAnalysisRuleDto>,
1605    #[serde(rename = "disconnectedNodeAcknowledged")]
1606    pub disconnected_node_acknowledged: Option<bool>,
1607    pub id: Option<String>,
1608    #[serde(rename = "operatePermissions")]
1609    pub operate_permissions: Option<PermissionsDto>,
1610    pub permissions: Option<PermissionsDto>,
1611    pub position: Option<PositionDto>,
1612    pub revision: Option<RevisionDto>,
1613    pub status: Option<FlowAnalysisRuleStatusDto>,
1614    pub uri: Option<String>,
1615}
1616
1617#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1618#[serde(rename_all = "camelCase")]
1619pub struct FlowAnalysisRuleRunStatusEntity {
1620    #[serde(rename = "disconnectedNodeAcknowledged")]
1621    pub disconnected_node_acknowledged: Option<bool>,
1622    pub revision: Option<RevisionDto>,
1623    pub state: Option<String>,
1624}
1625
1626#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1627#[serde(rename_all = "camelCase")]
1628pub struct FlowAnalysisRuleStatusDto {
1629    #[serde(rename = "activeThreadCount")]
1630    pub active_thread_count: Option<i32>,
1631    #[serde(rename = "runStatus")]
1632    pub run_status: Option<String>,
1633    #[serde(rename = "validationStatus")]
1634    pub validation_status: Option<String>,
1635}
1636
1637#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1638#[serde(rename_all = "camelCase")]
1639pub struct FlowAnalysisRuleTypesEntity {
1640    #[serde(rename = "flowAnalysisRuleTypes")]
1641    pub flow_analysis_rule_types: Option<Vec<DocumentedTypeDto>>,
1642}
1643
1644#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1645#[serde(rename_all = "camelCase")]
1646pub struct FlowAnalysisRuleViolationDto {
1647    pub enabled: Option<bool>,
1648    #[serde(rename = "enforcementPolicy")]
1649    pub enforcement_policy: Option<String>,
1650    #[serde(rename = "groupId")]
1651    pub group_id: Option<String>,
1652    #[serde(rename = "issueId")]
1653    pub issue_id: Option<String>,
1654    #[serde(rename = "ruleId")]
1655    pub rule_id: Option<String>,
1656    pub scope: Option<String>,
1657    #[serde(rename = "subjectComponentType")]
1658    pub subject_component_type: Option<String>,
1659    #[serde(rename = "subjectDisplayName")]
1660    pub subject_display_name: Option<String>,
1661    #[serde(rename = "subjectId")]
1662    pub subject_id: Option<String>,
1663    #[serde(rename = "subjectPermissionDto")]
1664    pub subject_permission_dto: Option<PermissionsDto>,
1665    #[serde(rename = "violationMessage")]
1666    pub violation_message: Option<String>,
1667}
1668
1669#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1670#[serde(rename_all = "camelCase")]
1671pub struct FlowAnalysisRulesEntity {
1672    #[serde(rename = "currentTime")]
1673    pub current_time: Option<String>,
1674    #[serde(rename = "flowAnalysisRules")]
1675    pub flow_analysis_rules: Option<Vec<FlowAnalysisRuleEntity>>,
1676}
1677
1678#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1679#[serde(rename_all = "camelCase")]
1680pub struct FlowBreadcrumbDto {
1681    pub id: Option<String>,
1682    pub name: Option<String>,
1683    #[serde(rename = "versionControlInformation")]
1684    pub version_control_information: Option<VersionControlInformationDto>,
1685}
1686
1687#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1688#[serde(rename_all = "camelCase")]
1689pub struct FlowBreadcrumbEntity {
1690    pub breadcrumb: Option<FlowBreadcrumbDto>,
1691    pub id: Option<String>,
1692    #[serde(rename = "parentBreadcrumb")]
1693    pub parent_breadcrumb: Option<Box<FlowBreadcrumbEntity>>,
1694    pub permissions: Option<PermissionsDto>,
1695    #[serde(rename = "versionedFlowState")]
1696    pub versioned_flow_state: Option<String>,
1697}
1698
1699#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1700#[serde(rename_all = "camelCase")]
1701pub struct FlowComparisonEntity {
1702    #[serde(rename = "componentDifferences")]
1703    pub component_differences: Option<Vec<ComponentDifferenceDto>>,
1704}
1705
1706#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1707#[serde(rename_all = "camelCase")]
1708pub struct FlowConfigurationDto {
1709    #[serde(rename = "currentTime")]
1710    pub current_time: Option<String>,
1711    #[serde(rename = "defaultBackPressureDataSizeThreshold")]
1712    pub default_back_pressure_data_size_threshold: Option<String>,
1713    #[serde(rename = "defaultBackPressureObjectThreshold")]
1714    pub default_back_pressure_object_threshold: Option<i64>,
1715    #[serde(rename = "supportsConfigurableAuthorizer")]
1716    pub supports_configurable_authorizer: Option<bool>,
1717    #[serde(rename = "supportsConfigurableUsersAndGroups")]
1718    pub supports_configurable_users_and_groups: Option<bool>,
1719    #[serde(rename = "supportsManagedAuthorizer")]
1720    pub supports_managed_authorizer: Option<bool>,
1721    #[serde(rename = "timeOffset")]
1722    pub time_offset: Option<i32>,
1723}
1724
1725#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1726#[serde(rename_all = "camelCase")]
1727pub(crate) struct FlowConfigurationEntity {
1728    pub flow_configuration: Option<FlowConfigurationDto>,
1729}
1730
1731#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1732#[serde(rename_all = "camelCase")]
1733pub struct FlowDto {
1734    pub connections: Option<Vec<ConnectionEntity>>,
1735    pub funnels: Option<Vec<FunnelEntity>>,
1736    #[serde(rename = "inputPorts")]
1737    pub input_ports: Option<Vec<PortEntity>>,
1738    pub labels: Option<Vec<LabelEntity>>,
1739    #[serde(rename = "outputPorts")]
1740    pub output_ports: Option<Vec<PortEntity>>,
1741    #[serde(rename = "processGroups")]
1742    pub process_groups: Option<Vec<ProcessGroupEntity>>,
1743    pub processors: Option<Vec<ProcessorEntity>>,
1744    #[serde(rename = "remoteProcessGroups")]
1745    pub remote_process_groups: Option<Vec<RemoteProcessGroupEntity>>,
1746}
1747
1748#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1749#[serde(rename_all = "camelCase")]
1750pub(crate) struct FlowEntity {
1751    pub flow: Option<FlowDto>,
1752}
1753
1754#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1755#[serde(rename_all = "camelCase")]
1756pub struct FlowFileDto {
1757    pub attributes: Option<std::collections::HashMap<String, Option<String>>>,
1758    #[serde(rename = "clusterNodeAddress")]
1759    pub cluster_node_address: Option<String>,
1760    #[serde(rename = "clusterNodeId")]
1761    pub cluster_node_id: Option<String>,
1762    #[serde(rename = "contentClaimContainer")]
1763    pub content_claim_container: Option<String>,
1764    #[serde(rename = "contentClaimFileSize")]
1765    pub content_claim_file_size: Option<String>,
1766    #[serde(rename = "contentClaimFileSizeBytes")]
1767    pub content_claim_file_size_bytes: Option<i64>,
1768    #[serde(rename = "contentClaimIdentifier")]
1769    pub content_claim_identifier: Option<String>,
1770    #[serde(rename = "contentClaimOffset")]
1771    pub content_claim_offset: Option<i64>,
1772    #[serde(rename = "contentClaimSection")]
1773    pub content_claim_section: Option<String>,
1774    pub filename: Option<String>,
1775    #[serde(rename = "lineageDuration")]
1776    pub lineage_duration: Option<i64>,
1777    #[serde(rename = "mimeType")]
1778    pub mime_type: Option<String>,
1779    pub penalized: Option<bool>,
1780    #[serde(rename = "penaltyExpiresIn")]
1781    pub penalty_expires_in: Option<i64>,
1782    pub position: Option<i32>,
1783    #[serde(rename = "queuedDuration")]
1784    pub queued_duration: Option<i64>,
1785    pub size: Option<i64>,
1786    pub uri: Option<String>,
1787    pub uuid: Option<String>,
1788}
1789
1790#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1791#[serde(rename_all = "camelCase")]
1792pub(crate) struct FlowFileEntity {
1793    pub flow_file: Option<FlowFileDto>,
1794}
1795
1796#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1797#[serde(rename_all = "camelCase")]
1798pub struct FlowFileSummaryDto {
1799    #[serde(rename = "clusterNodeAddress")]
1800    pub cluster_node_address: Option<String>,
1801    #[serde(rename = "clusterNodeId")]
1802    pub cluster_node_id: Option<String>,
1803    pub filename: Option<String>,
1804    #[serde(rename = "lineageDuration")]
1805    pub lineage_duration: Option<i64>,
1806    #[serde(rename = "mimeType")]
1807    pub mime_type: Option<String>,
1808    pub penalized: Option<bool>,
1809    #[serde(rename = "penaltyExpiresIn")]
1810    pub penalty_expires_in: Option<i64>,
1811    pub position: Option<i32>,
1812    #[serde(rename = "queuedDuration")]
1813    pub queued_duration: Option<i64>,
1814    pub size: Option<i64>,
1815    pub uri: Option<String>,
1816    pub uuid: Option<String>,
1817}
1818
1819#[derive(Debug, Clone, Deserialize, Serialize)]
1820pub enum FlowMetricsReportingStrategy {
1821    #[serde(rename = "ALL_COMPONENTS")]
1822    AllComponents,
1823    #[serde(rename = "ALL_PROCESS_GROUPS")]
1824    AllProcessGroups,
1825}
1826
1827#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1828#[serde(rename_all = "camelCase")]
1829pub struct FlowRegistryBranchDto {
1830    pub name: Option<String>,
1831}
1832
1833#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1834#[serde(rename_all = "camelCase")]
1835pub(crate) struct FlowRegistryBranchEntity {
1836    pub branch: Option<FlowRegistryBranchDto>,
1837}
1838
1839#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1840#[serde(rename_all = "camelCase")]
1841pub struct FlowRegistryBranchesEntity {
1842    pub branches: Option<Vec<FlowRegistryBranchEntity>>,
1843}
1844
1845#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1846#[serde(rename_all = "camelCase")]
1847pub struct FlowRegistryBucket {
1848    #[serde(rename = "createdTimestamp")]
1849    pub created_timestamp: Option<i64>,
1850    pub description: Option<String>,
1851    pub identifier: Option<String>,
1852    pub name: Option<String>,
1853    pub permissions: Option<FlowRegistryPermissions>,
1854}
1855
1856#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1857#[serde(rename_all = "camelCase")]
1858pub struct FlowRegistryBucketDto {
1859    pub created: Option<i64>,
1860    pub description: Option<String>,
1861    pub id: Option<String>,
1862    pub name: Option<String>,
1863}
1864
1865#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1866#[serde(rename_all = "camelCase")]
1867pub struct FlowRegistryBucketEntity {
1868    pub bucket: Option<FlowRegistryBucketDto>,
1869    pub id: Option<String>,
1870    pub permissions: Option<PermissionsDto>,
1871}
1872
1873#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1874#[serde(rename_all = "camelCase")]
1875pub struct FlowRegistryBucketsEntity {
1876    pub buckets: Option<Vec<FlowRegistryBucketEntity>>,
1877}
1878
1879#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1880#[serde(rename_all = "camelCase")]
1881pub struct FlowRegistryClientDefinition {
1882    #[serde(rename = "additionalDetails")]
1883    pub additional_details: Option<bool>,
1884    pub artifact: Option<String>,
1885    #[serde(rename = "buildInfo")]
1886    pub build_info: Option<BuildInfo>,
1887    pub deprecated: Option<bool>,
1888    #[serde(rename = "deprecationAlternatives")]
1889    pub deprecation_alternatives: Option<Vec<String>>,
1890    #[serde(rename = "deprecationReason")]
1891    pub deprecation_reason: Option<String>,
1892    #[serde(rename = "dynamicProperties")]
1893    pub dynamic_properties: Option<Vec<DynamicProperty>>,
1894    #[serde(rename = "explicitRestrictions")]
1895    pub explicit_restrictions: Option<Vec<Restriction>>,
1896    pub group: Option<String>,
1897    #[serde(rename = "propertyDescriptors")]
1898    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
1899    #[serde(rename = "providedApiImplementations")]
1900    pub provided_api_implementations: Option<Vec<DefinedType>>,
1901    pub restricted: Option<bool>,
1902    #[serde(rename = "restrictedExplanation")]
1903    pub restricted_explanation: Option<String>,
1904    #[serde(rename = "seeAlso")]
1905    pub see_also: Option<Vec<String>>,
1906    pub stateful: Option<Stateful>,
1907    #[serde(rename = "supportsDynamicProperties")]
1908    pub supports_dynamic_properties: Option<bool>,
1909    #[serde(rename = "supportsSensitiveDynamicProperties")]
1910    pub supports_sensitive_dynamic_properties: Option<bool>,
1911    #[serde(rename = "systemResourceConsiderations")]
1912    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
1913    pub tags: Option<Vec<String>>,
1914    pub r#type: Option<String>,
1915    #[serde(rename = "typeDescription")]
1916    pub type_description: Option<String>,
1917    pub version: Option<String>,
1918}
1919
1920#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1921#[serde(rename_all = "camelCase")]
1922pub struct FlowRegistryClientDto {
1923    #[serde(rename = "annotationData")]
1924    pub annotation_data: Option<String>,
1925    pub bundle: Option<BundleDto>,
1926    pub deprecated: Option<bool>,
1927    pub description: Option<String>,
1928    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
1929    #[serde(rename = "extensionMissing")]
1930    pub extension_missing: Option<bool>,
1931    pub id: Option<String>,
1932    #[serde(rename = "multipleVersionsAvailable")]
1933    pub multiple_versions_available: Option<bool>,
1934    pub name: Option<String>,
1935    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
1936    pub restricted: Option<bool>,
1937    #[serde(rename = "sensitiveDynamicPropertyNames")]
1938    pub sensitive_dynamic_property_names: Option<Vec<String>>,
1939    #[serde(rename = "supportsBranching")]
1940    pub supports_branching: Option<bool>,
1941    #[serde(rename = "supportsSensitiveDynamicProperties")]
1942    pub supports_sensitive_dynamic_properties: Option<bool>,
1943    pub r#type: Option<String>,
1944    #[serde(rename = "validationErrors")]
1945    pub validation_errors: Option<Vec<String>>,
1946    #[serde(rename = "validationStatus")]
1947    pub validation_status: Option<String>,
1948}
1949
1950#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1951#[serde(rename_all = "camelCase")]
1952pub struct FlowRegistryClientEntity {
1953    pub bulletins: Option<Vec<BulletinEntity>>,
1954    pub component: Option<FlowRegistryClientDto>,
1955    #[serde(rename = "disconnectedNodeAcknowledged")]
1956    pub disconnected_node_acknowledged: Option<bool>,
1957    pub id: Option<String>,
1958    #[serde(rename = "operatePermissions")]
1959    pub operate_permissions: Option<PermissionsDto>,
1960    pub permissions: Option<PermissionsDto>,
1961    pub position: Option<PositionDto>,
1962    pub revision: Option<RevisionDto>,
1963    pub uri: Option<String>,
1964}
1965
1966#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1967#[serde(rename_all = "camelCase")]
1968pub struct FlowRegistryClientTypesEntity {
1969    #[serde(rename = "flowRegistryClientTypes")]
1970    pub flow_registry_client_types: Option<Vec<DocumentedTypeDto>>,
1971}
1972
1973#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1974#[serde(rename_all = "camelCase")]
1975pub struct FlowRegistryClientsEntity {
1976    #[serde(rename = "currentTime")]
1977    pub current_time: Option<String>,
1978    pub registries: Option<Vec<FlowRegistryClientEntity>>,
1979}
1980
1981#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1982#[serde(rename_all = "camelCase")]
1983pub struct FlowRegistryPermissions {
1984    #[serde(rename = "canDelete")]
1985    pub can_delete: Option<bool>,
1986    #[serde(rename = "canRead")]
1987    pub can_read: Option<bool>,
1988    #[serde(rename = "canWrite")]
1989    pub can_write: Option<bool>,
1990}
1991
1992#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1993#[serde(rename_all = "camelCase")]
1994pub struct FlowSnippetDto {
1995    pub connections: Option<Vec<ConnectionDto>>,
1996    #[serde(rename = "controllerServices")]
1997    pub controller_services: Option<Vec<ControllerServiceDto>>,
1998    pub funnels: Option<Vec<FunnelDto>>,
1999    #[serde(rename = "inputPorts")]
2000    pub input_ports: Option<Vec<PortDto>>,
2001    pub labels: Option<Vec<LabelDto>>,
2002    #[serde(rename = "outputPorts")]
2003    pub output_ports: Option<Vec<PortDto>>,
2004    #[serde(rename = "processGroups")]
2005    pub process_groups: Option<Vec<ProcessGroupDto>>,
2006    pub processors: Option<Vec<ProcessorDto>>,
2007    #[serde(rename = "remoteProcessGroups")]
2008    pub remote_process_groups: Option<Vec<RemoteProcessGroupDto>>,
2009}
2010
2011#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2012#[serde(rename_all = "camelCase")]
2013pub struct FunnelDto {
2014    pub id: Option<String>,
2015    #[serde(rename = "parentGroupId")]
2016    pub parent_group_id: Option<String>,
2017    pub position: Option<PositionDto>,
2018    #[serde(rename = "versionedComponentId")]
2019    pub versioned_component_id: Option<String>,
2020}
2021
2022#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2023#[serde(rename_all = "camelCase")]
2024pub struct FunnelEntity {
2025    pub bulletins: Option<Vec<BulletinEntity>>,
2026    pub component: Option<FunnelDto>,
2027    #[serde(rename = "disconnectedNodeAcknowledged")]
2028    pub disconnected_node_acknowledged: Option<bool>,
2029    pub id: Option<String>,
2030    pub permissions: Option<PermissionsDto>,
2031    pub position: Option<PositionDto>,
2032    pub revision: Option<RevisionDto>,
2033    pub uri: Option<String>,
2034}
2035
2036#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2037#[serde(rename_all = "camelCase")]
2038pub struct FunnelsEntity {
2039    pub funnels: Option<Vec<FunnelEntity>>,
2040}
2041
2042#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2043#[serde(rename_all = "camelCase")]
2044pub struct GarbageCollectionDto {
2045    #[serde(rename = "collectionCount")]
2046    pub collection_count: Option<i64>,
2047    #[serde(rename = "collectionMillis")]
2048    pub collection_millis: Option<i64>,
2049    #[serde(rename = "collectionTime")]
2050    pub collection_time: Option<String>,
2051    pub name: Option<String>,
2052}
2053
2054#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2055#[serde(rename_all = "camelCase")]
2056pub struct HistoryDto {
2057    pub actions: Option<Vec<ActionEntity>>,
2058    #[serde(rename = "lastRefreshed")]
2059    pub last_refreshed: Option<String>,
2060    pub total: Option<i32>,
2061}
2062
2063#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2064#[serde(rename_all = "camelCase")]
2065pub(crate) struct HistoryEntity {
2066    pub history: Option<HistoryDto>,
2067}
2068
2069#[derive(Debug, Clone, Deserialize, Serialize)]
2070pub enum IncludedRegistries {
2071    #[serde(rename = "BULLETIN")]
2072    Bulletin,
2073    #[serde(rename = "CLUSTER")]
2074    Cluster,
2075    #[serde(rename = "CONNECTION")]
2076    Connection,
2077    #[serde(rename = "JVM")]
2078    Jvm,
2079    #[serde(rename = "NIFI")]
2080    Nifi,
2081    #[serde(rename = "VERSION_INFO")]
2082    VersionInfo,
2083}
2084
2085#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2086#[serde(rename_all = "camelCase")]
2087pub struct InputPortsEntity {
2088    #[serde(rename = "inputPorts")]
2089    pub input_ports: Option<Vec<PortEntity>>,
2090}
2091
2092#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2093#[serde(rename_all = "camelCase")]
2094pub struct IntegerParameter {
2095    pub integer: Option<i32>,
2096}
2097
2098#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2099#[serde(rename_all = "camelCase")]
2100pub struct JmxMetricsResultDto {
2101    #[serde(rename = "attributeName")]
2102    pub attribute_name: Option<String>,
2103    #[serde(rename = "attributeValue")]
2104    pub attribute_value: Option<serde_json::Value>,
2105    #[serde(rename = "beanName")]
2106    pub bean_name: Option<String>,
2107}
2108
2109#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2110#[serde(rename_all = "camelCase")]
2111pub struct JmxMetricsResultsEntity {
2112    #[serde(rename = "jmxMetricsResults")]
2113    pub jmx_metrics_results: Option<Vec<JmxMetricsResultDto>>,
2114}
2115
2116#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2117#[serde(rename_all = "camelCase")]
2118pub struct LabelDto {
2119    #[serde(rename = "getzIndex")]
2120    pub getz_index: Option<i64>,
2121    pub height: Option<f64>,
2122    pub id: Option<String>,
2123    pub label: Option<String>,
2124    #[serde(rename = "parentGroupId")]
2125    pub parent_group_id: Option<String>,
2126    pub position: Option<PositionDto>,
2127    pub style: Option<std::collections::HashMap<String, Option<String>>>,
2128    #[serde(rename = "versionedComponentId")]
2129    pub versioned_component_id: Option<String>,
2130    pub width: Option<f64>,
2131}
2132
2133#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2134#[serde(rename_all = "camelCase")]
2135pub struct LabelEntity {
2136    pub bulletins: Option<Vec<BulletinEntity>>,
2137    pub component: Option<LabelDto>,
2138    pub dimensions: Option<DimensionsDto>,
2139    #[serde(rename = "disconnectedNodeAcknowledged")]
2140    pub disconnected_node_acknowledged: Option<bool>,
2141    #[serde(rename = "getzIndex")]
2142    pub getz_index: Option<i64>,
2143    pub id: Option<String>,
2144    pub permissions: Option<PermissionsDto>,
2145    pub position: Option<PositionDto>,
2146    pub revision: Option<RevisionDto>,
2147    pub uri: Option<String>,
2148}
2149
2150#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2151#[serde(rename_all = "camelCase")]
2152pub struct LabelsEntity {
2153    pub labels: Option<Vec<LabelEntity>>,
2154}
2155
2156#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2157#[serde(rename_all = "camelCase")]
2158pub struct LatestProvenanceEventsDto {
2159    #[serde(rename = "componentId")]
2160    pub component_id: Option<String>,
2161    #[serde(rename = "provenanceEvents")]
2162    pub provenance_events: Option<Vec<ProvenanceEventDto>>,
2163}
2164
2165#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2166#[serde(rename_all = "camelCase")]
2167pub(crate) struct LatestProvenanceEventsEntity {
2168    pub latest_provenance_events: Option<LatestProvenanceEventsDto>,
2169}
2170
2171#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2172#[serde(rename_all = "camelCase")]
2173pub struct LineageDto {
2174    pub expiration: Option<String>,
2175    pub finished: Option<bool>,
2176    pub id: Option<String>,
2177    #[serde(rename = "percentCompleted")]
2178    pub percent_completed: Option<i32>,
2179    pub request: Option<LineageRequestDto>,
2180    pub results: Option<LineageResultsDto>,
2181    #[serde(rename = "submissionTime")]
2182    pub submission_time: Option<String>,
2183    pub uri: Option<String>,
2184}
2185
2186#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2187#[serde(rename_all = "camelCase")]
2188pub(crate) struct LineageEntity {
2189    pub lineage: Option<LineageDto>,
2190}
2191
2192#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2193#[serde(rename_all = "camelCase")]
2194pub struct LineageRequestDto {
2195    #[serde(rename = "clusterNodeId")]
2196    pub cluster_node_id: Option<String>,
2197    #[serde(rename = "eventId")]
2198    pub event_id: Option<i64>,
2199    #[serde(rename = "lineageRequestType")]
2200    pub lineage_request_type: Option<String>,
2201    pub uuid: Option<String>,
2202}
2203
2204#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2205#[serde(rename_all = "camelCase")]
2206pub struct LineageResultsDto {
2207    pub errors: Option<Vec<String>>,
2208    pub links: Option<Vec<ProvenanceLinkDto>>,
2209    pub nodes: Option<Vec<ProvenanceNodeDto>>,
2210}
2211
2212#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2213#[serde(rename_all = "camelCase")]
2214pub struct ListenPortDto {
2215    #[serde(rename = "applicationProtocols")]
2216    pub application_protocols: Option<Vec<String>>,
2217    #[serde(rename = "componentClass")]
2218    pub component_class: Option<String>,
2219    #[serde(rename = "componentId")]
2220    pub component_id: Option<String>,
2221    #[serde(rename = "componentName")]
2222    pub component_name: Option<String>,
2223    #[serde(rename = "componentType")]
2224    pub component_type: Option<String>,
2225    #[serde(rename = "parentGroupId")]
2226    pub parent_group_id: Option<String>,
2227    #[serde(rename = "parentGroupName")]
2228    pub parent_group_name: Option<String>,
2229    #[serde(rename = "portName")]
2230    pub port_name: Option<String>,
2231    #[serde(rename = "portNumber")]
2232    pub port_number: Option<i32>,
2233    #[serde(rename = "transportProtocol")]
2234    pub transport_protocol: Option<String>,
2235}
2236
2237#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2238#[serde(rename_all = "camelCase")]
2239pub struct ListenPortsEntity {
2240    #[serde(rename = "listenPorts")]
2241    pub listen_ports: Option<Vec<ListenPortDto>>,
2242}
2243
2244#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2245#[serde(rename_all = "camelCase")]
2246pub struct ListingRequestDto {
2247    #[serde(rename = "destinationRunning")]
2248    pub destination_running: Option<bool>,
2249    #[serde(rename = "failureReason")]
2250    pub failure_reason: Option<String>,
2251    pub finished: Option<bool>,
2252    #[serde(rename = "flowFileSummaries")]
2253    pub flow_file_summaries: Option<Vec<FlowFileSummaryDto>>,
2254    pub id: Option<String>,
2255    #[serde(rename = "lastUpdated")]
2256    pub last_updated: Option<String>,
2257    #[serde(rename = "maxResults")]
2258    pub max_results: Option<i32>,
2259    #[serde(rename = "percentCompleted")]
2260    pub percent_completed: Option<i32>,
2261    #[serde(rename = "queueSize")]
2262    pub queue_size: Option<QueueSizeDto>,
2263    #[serde(rename = "sourceRunning")]
2264    pub source_running: Option<bool>,
2265    pub state: Option<String>,
2266    #[serde(rename = "submissionTime")]
2267    pub submission_time: Option<String>,
2268    pub uri: Option<String>,
2269}
2270
2271#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2272#[serde(rename_all = "camelCase")]
2273pub(crate) struct ListingRequestEntity {
2274    pub listing_request: Option<ListingRequestDto>,
2275}
2276
2277#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2278#[serde(rename_all = "camelCase")]
2279pub struct LongParameter {
2280    pub long: Option<i64>,
2281}
2282
2283#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2284#[serde(rename_all = "camelCase")]
2285pub struct MultiProcessorUseCase {
2286    pub configurations: Option<Vec<ProcessorConfiguration>>,
2287    pub description: Option<String>,
2288    pub keywords: Option<Vec<String>>,
2289    pub notes: Option<String>,
2290}
2291
2292#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2293#[serde(rename_all = "camelCase")]
2294pub struct NarCoordinateDto {
2295    pub artifact: Option<String>,
2296    pub group: Option<String>,
2297    pub version: Option<String>,
2298}
2299
2300#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2301#[serde(rename_all = "camelCase")]
2302pub struct NarDetailsEntity {
2303    #[serde(rename = "controllerServiceTypes")]
2304    pub controller_service_types: Option<Vec<DocumentedTypeDto>>,
2305    #[serde(rename = "dependentCoordinates")]
2306    pub dependent_coordinates: Option<Vec<NarCoordinateDto>>,
2307    #[serde(rename = "flowAnalysisRuleTypes")]
2308    pub flow_analysis_rule_types: Option<Vec<DocumentedTypeDto>>,
2309    #[serde(rename = "flowRegistryClientTypes")]
2310    pub flow_registry_client_types: Option<Vec<DocumentedTypeDto>>,
2311    #[serde(rename = "narSummary")]
2312    pub nar_summary: Option<NarSummaryDto>,
2313    #[serde(rename = "parameterProviderTypes")]
2314    pub parameter_provider_types: Option<Vec<DocumentedTypeDto>>,
2315    #[serde(rename = "processorTypes")]
2316    pub processor_types: Option<Vec<DocumentedTypeDto>>,
2317    #[serde(rename = "reportingTaskTypes")]
2318    pub reporting_task_types: Option<Vec<DocumentedTypeDto>>,
2319}
2320
2321#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2322#[serde(rename_all = "camelCase")]
2323pub struct NarSummariesEntity {
2324    #[serde(rename = "currentTime")]
2325    pub current_time: Option<String>,
2326    #[serde(rename = "narSummaries")]
2327    pub nar_summaries: Option<Vec<NarSummaryEntity>>,
2328}
2329
2330#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2331#[serde(rename_all = "camelCase")]
2332pub struct NarSummaryDto {
2333    #[serde(rename = "buildTime")]
2334    pub build_time: Option<String>,
2335    pub coordinate: Option<NarCoordinateDto>,
2336    #[serde(rename = "createdBy")]
2337    pub created_by: Option<String>,
2338    #[serde(rename = "dependencyCoordinate")]
2339    pub dependency_coordinate: Option<NarCoordinateDto>,
2340    pub digest: Option<String>,
2341    #[serde(rename = "extensionCount")]
2342    pub extension_count: Option<i32>,
2343    #[serde(rename = "failureMessage")]
2344    pub failure_message: Option<String>,
2345    pub identifier: Option<String>,
2346    #[serde(rename = "installComplete")]
2347    pub install_complete: Option<bool>,
2348    #[serde(rename = "sourceIdentifier")]
2349    pub source_identifier: Option<String>,
2350    #[serde(rename = "sourceType")]
2351    pub source_type: Option<String>,
2352    pub state: Option<String>,
2353}
2354
2355#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2356#[serde(rename_all = "camelCase")]
2357pub(crate) struct NarSummaryEntity {
2358    pub nar_summary: Option<NarSummaryDto>,
2359}
2360
2361#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2362#[serde(rename_all = "camelCase")]
2363pub struct NodeConnectionStatisticsSnapshotDto {
2364    pub address: Option<String>,
2365    #[serde(rename = "apiPort")]
2366    pub api_port: Option<i32>,
2367    #[serde(rename = "nodeId")]
2368    pub node_id: Option<String>,
2369    #[serde(rename = "statisticsSnapshot")]
2370    pub statistics_snapshot: Option<ConnectionStatisticsSnapshotDto>,
2371}
2372
2373#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2374#[serde(rename_all = "camelCase")]
2375pub struct NodeConnectionStatusSnapshotDto {
2376    pub address: Option<String>,
2377    #[serde(rename = "apiPort")]
2378    pub api_port: Option<i32>,
2379    #[serde(rename = "nodeId")]
2380    pub node_id: Option<String>,
2381    #[serde(rename = "statusSnapshot")]
2382    pub status_snapshot: Option<ConnectionStatusSnapshotDto>,
2383}
2384
2385#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2386#[serde(rename_all = "camelCase")]
2387pub struct NodeCountersSnapshotDto {
2388    pub address: Option<String>,
2389    #[serde(rename = "apiPort")]
2390    pub api_port: Option<i32>,
2391    #[serde(rename = "nodeId")]
2392    pub node_id: Option<String>,
2393    pub snapshot: Option<CountersSnapshotDto>,
2394}
2395
2396#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2397#[serde(rename_all = "camelCase")]
2398pub struct NodeDto {
2399    #[serde(rename = "activeThreadCount")]
2400    pub active_thread_count: Option<i32>,
2401    pub address: Option<String>,
2402    #[serde(rename = "apiPort")]
2403    pub api_port: Option<i32>,
2404    #[serde(rename = "bytesQueued")]
2405    pub bytes_queued: Option<i64>,
2406    #[serde(rename = "connectionRequested")]
2407    pub connection_requested: Option<String>,
2408    pub events: Option<Vec<NodeEventDto>>,
2409    #[serde(rename = "flowFileBytes")]
2410    pub flow_file_bytes: Option<i64>,
2411    #[serde(rename = "flowFilesQueued")]
2412    pub flow_files_queued: Option<i32>,
2413    pub heartbeat: Option<String>,
2414    #[serde(rename = "nodeId")]
2415    pub node_id: Option<String>,
2416    #[serde(rename = "nodeStartTime")]
2417    pub node_start_time: Option<String>,
2418    pub queued: Option<String>,
2419    pub roles: Option<Vec<String>>,
2420    pub status: Option<String>,
2421}
2422
2423#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2424#[serde(rename_all = "camelCase")]
2425pub(crate) struct NodeEntity {
2426    pub node: Option<NodeDto>,
2427}
2428
2429#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2430#[serde(rename_all = "camelCase")]
2431pub struct NodeEventDto {
2432    pub category: Option<String>,
2433    pub message: Option<String>,
2434    pub timestamp: Option<String>,
2435}
2436
2437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2438#[serde(rename_all = "camelCase")]
2439pub struct NodePortStatusSnapshotDto {
2440    pub address: Option<String>,
2441    #[serde(rename = "apiPort")]
2442    pub api_port: Option<i32>,
2443    #[serde(rename = "nodeId")]
2444    pub node_id: Option<String>,
2445    #[serde(rename = "statusSnapshot")]
2446    pub status_snapshot: Option<PortStatusSnapshotDto>,
2447}
2448
2449#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2450#[serde(rename_all = "camelCase")]
2451pub struct NodeProcessGroupStatusSnapshotDto {
2452    pub address: Option<String>,
2453    #[serde(rename = "apiPort")]
2454    pub api_port: Option<i32>,
2455    #[serde(rename = "nodeId")]
2456    pub node_id: Option<String>,
2457    #[serde(rename = "statusSnapshot")]
2458    pub status_snapshot: Option<ProcessGroupStatusSnapshotDto>,
2459}
2460
2461#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2462#[serde(rename_all = "camelCase")]
2463pub struct NodeProcessorStatusSnapshotDto {
2464    pub address: Option<String>,
2465    #[serde(rename = "apiPort")]
2466    pub api_port: Option<i32>,
2467    #[serde(rename = "nodeId")]
2468    pub node_id: Option<String>,
2469    #[serde(rename = "statusSnapshot")]
2470    pub status_snapshot: Option<ProcessorStatusSnapshotDto>,
2471}
2472
2473#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2474#[serde(rename_all = "camelCase")]
2475pub struct NodeRemoteProcessGroupStatusSnapshotDto {
2476    pub address: Option<String>,
2477    #[serde(rename = "apiPort")]
2478    pub api_port: Option<i32>,
2479    #[serde(rename = "nodeId")]
2480    pub node_id: Option<String>,
2481    #[serde(rename = "statusSnapshot")]
2482    pub status_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
2483}
2484
2485#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2486#[serde(rename_all = "camelCase")]
2487pub struct NodeReplayLastEventSnapshotDto {
2488    pub address: Option<String>,
2489    #[serde(rename = "apiPort")]
2490    pub api_port: Option<i32>,
2491    #[serde(rename = "nodeId")]
2492    pub node_id: Option<String>,
2493    pub snapshot: Option<ReplayLastEventSnapshotDto>,
2494}
2495
2496#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2497#[serde(rename_all = "camelCase")]
2498pub struct NodeSearchResultDto {
2499    pub address: Option<String>,
2500    pub id: Option<String>,
2501}
2502
2503#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2504#[serde(rename_all = "camelCase")]
2505pub struct NodeStatusSnapshotsDto {
2506    pub address: Option<String>,
2507    #[serde(rename = "apiPort")]
2508    pub api_port: Option<i32>,
2509    #[serde(rename = "nodeId")]
2510    pub node_id: Option<String>,
2511    #[serde(rename = "statusSnapshots")]
2512    pub status_snapshots: Option<Vec<StatusSnapshotDto>>,
2513}
2514
2515#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2516#[serde(rename_all = "camelCase")]
2517pub struct NodeSystemDiagnosticsSnapshotDto {
2518    pub address: Option<String>,
2519    #[serde(rename = "apiPort")]
2520    pub api_port: Option<i32>,
2521    #[serde(rename = "nodeId")]
2522    pub node_id: Option<String>,
2523    pub snapshot: Option<SystemDiagnosticsSnapshotDto>,
2524}
2525
2526#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2527#[serde(rename_all = "camelCase")]
2528pub struct OutputPortsEntity {
2529    #[serde(rename = "outputPorts")]
2530    pub output_ports: Option<Vec<PortEntity>>,
2531}
2532
2533#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2534#[serde(rename_all = "camelCase")]
2535pub struct ParameterContextDto {
2536    #[serde(rename = "boundProcessGroups")]
2537    pub bound_process_groups: Option<Vec<ProcessGroupEntity>>,
2538    pub description: Option<String>,
2539    pub id: Option<String>,
2540    #[serde(rename = "inheritedParameterContexts")]
2541    pub inherited_parameter_contexts: Option<Vec<ParameterContextReferenceEntity>>,
2542    pub name: Option<String>,
2543    #[serde(rename = "parameterProviderConfiguration")]
2544    pub parameter_provider_configuration: Option<ParameterProviderConfigurationEntity>,
2545    pub parameters: Option<Vec<ParameterEntity>>,
2546}
2547
2548#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2549#[serde(rename_all = "camelCase")]
2550pub struct ParameterContextEntity {
2551    pub bulletins: Option<Vec<BulletinEntity>>,
2552    pub component: Option<ParameterContextDto>,
2553    #[serde(rename = "disconnectedNodeAcknowledged")]
2554    pub disconnected_node_acknowledged: Option<bool>,
2555    pub id: Option<String>,
2556    pub permissions: Option<PermissionsDto>,
2557    pub position: Option<PositionDto>,
2558    pub revision: Option<RevisionDto>,
2559    pub uri: Option<String>,
2560}
2561
2562#[derive(Debug, Clone, Deserialize, Serialize)]
2563pub enum ParameterContextHandlingStrategy {
2564    #[serde(rename = "KEEP_EXISTING")]
2565    KeepExisting,
2566    #[serde(rename = "REPLACE")]
2567    Replace,
2568}
2569
2570#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2571#[serde(rename_all = "camelCase")]
2572pub struct ParameterContextReferenceDto {
2573    pub id: Option<String>,
2574    pub name: Option<String>,
2575}
2576
2577#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2578#[serde(rename_all = "camelCase")]
2579pub struct ParameterContextReferenceEntity {
2580    pub component: Option<ParameterContextReferenceDto>,
2581    pub id: Option<String>,
2582    pub permissions: Option<PermissionsDto>,
2583}
2584
2585#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2586#[serde(rename_all = "camelCase")]
2587pub struct ParameterContextUpdateEntity {
2588    #[serde(rename = "parameterContext")]
2589    pub parameter_context: Option<ParameterContextDto>,
2590    #[serde(rename = "parameterContextRevision")]
2591    pub parameter_context_revision: Option<RevisionDto>,
2592    #[serde(rename = "referencingComponents")]
2593    pub referencing_components: Option<Vec<AffectedComponentEntity>>,
2594}
2595
2596#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2597#[serde(rename_all = "camelCase")]
2598pub struct ParameterContextUpdateRequestDto {
2599    pub complete: Option<bool>,
2600    #[serde(rename = "failureReason")]
2601    pub failure_reason: Option<String>,
2602    #[serde(rename = "lastUpdated")]
2603    pub last_updated: Option<String>,
2604    #[serde(rename = "parameterContext")]
2605    pub parameter_context: Option<ParameterContextDto>,
2606    #[serde(rename = "percentCompleted")]
2607    pub percent_completed: Option<i32>,
2608    #[serde(rename = "referencingComponents")]
2609    pub referencing_components: Option<Vec<AffectedComponentEntity>>,
2610    #[serde(rename = "requestId")]
2611    pub request_id: Option<String>,
2612    pub state: Option<String>,
2613    #[serde(rename = "submissionTime")]
2614    pub submission_time: Option<String>,
2615    #[serde(rename = "updateSteps")]
2616    pub update_steps: Option<Vec<ParameterContextUpdateStepDto>>,
2617    pub uri: Option<String>,
2618}
2619
2620#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2621#[serde(rename_all = "camelCase")]
2622pub struct ParameterContextUpdateRequestEntity {
2623    #[serde(rename = "parameterContextRevision")]
2624    pub parameter_context_revision: Option<RevisionDto>,
2625    pub request: Option<ParameterContextUpdateRequestDto>,
2626}
2627
2628#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2629#[serde(rename_all = "camelCase")]
2630pub struct ParameterContextUpdateStepDto {
2631    pub complete: Option<bool>,
2632    pub description: Option<String>,
2633    #[serde(rename = "failureReason")]
2634    pub failure_reason: Option<String>,
2635}
2636
2637#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2638#[serde(rename_all = "camelCase")]
2639pub struct ParameterContextValidationRequestDto {
2640    pub complete: Option<bool>,
2641    #[serde(rename = "componentValidationResults")]
2642    pub component_validation_results: Option<ComponentValidationResultsEntity>,
2643    #[serde(rename = "failureReason")]
2644    pub failure_reason: Option<String>,
2645    #[serde(rename = "lastUpdated")]
2646    pub last_updated: Option<String>,
2647    #[serde(rename = "parameterContext")]
2648    pub parameter_context: Option<ParameterContextDto>,
2649    #[serde(rename = "percentCompleted")]
2650    pub percent_completed: Option<i32>,
2651    #[serde(rename = "requestId")]
2652    pub request_id: Option<String>,
2653    pub state: Option<String>,
2654    #[serde(rename = "submissionTime")]
2655    pub submission_time: Option<String>,
2656    #[serde(rename = "updateSteps")]
2657    pub update_steps: Option<Vec<ParameterContextValidationStepDto>>,
2658    pub uri: Option<String>,
2659}
2660
2661#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2662#[serde(rename_all = "camelCase")]
2663pub struct ParameterContextValidationRequestEntity {
2664    #[serde(rename = "disconnectedNodeAcknowledged")]
2665    pub disconnected_node_acknowledged: Option<bool>,
2666    pub request: Option<ParameterContextValidationRequestDto>,
2667}
2668
2669#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2670#[serde(rename_all = "camelCase")]
2671pub struct ParameterContextValidationStepDto {
2672    pub complete: Option<bool>,
2673    pub description: Option<String>,
2674    #[serde(rename = "failureReason")]
2675    pub failure_reason: Option<String>,
2676}
2677
2678#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2679#[serde(rename_all = "camelCase")]
2680pub struct ParameterContextsEntity {
2681    #[serde(rename = "currentTime")]
2682    pub current_time: Option<String>,
2683    #[serde(rename = "parameterContexts")]
2684    pub parameter_contexts: Option<Vec<ParameterContextEntity>>,
2685}
2686
2687#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2688#[serde(rename_all = "camelCase")]
2689pub struct ParameterDto {
2690    pub description: Option<String>,
2691    pub inherited: Option<bool>,
2692    pub name: Option<String>,
2693    #[serde(rename = "parameterContext")]
2694    pub parameter_context: Option<ParameterContextReferenceEntity>,
2695    pub provided: Option<bool>,
2696    #[serde(rename = "referencedAssets")]
2697    pub referenced_assets: Option<Vec<AssetReferenceDto>>,
2698    #[serde(rename = "referencingComponents")]
2699    pub referencing_components: Option<Vec<AffectedComponentEntity>>,
2700    pub sensitive: Option<bool>,
2701    pub value: Option<String>,
2702    #[serde(rename = "valueRemoved")]
2703    pub value_removed: Option<bool>,
2704}
2705
2706#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2707#[serde(rename_all = "camelCase")]
2708pub struct ParameterEntity {
2709    #[serde(rename = "canWrite")]
2710    pub can_write: Option<bool>,
2711    pub parameter: Option<ParameterDto>,
2712}
2713
2714#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2715#[serde(rename_all = "camelCase")]
2716pub struct ParameterGroupConfigurationEntity {
2717    #[serde(rename = "groupName")]
2718    pub group_name: Option<String>,
2719    #[serde(rename = "parameterContextName")]
2720    pub parameter_context_name: Option<String>,
2721    #[serde(rename = "parameterSensitivities")]
2722    pub parameter_sensitivities: Option<std::collections::HashMap<String, Option<String>>>,
2723    pub synchronized: Option<bool>,
2724}
2725
2726#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2727#[serde(rename_all = "camelCase")]
2728pub struct ParameterProviderApplyParametersRequestDto {
2729    pub complete: Option<bool>,
2730    #[serde(rename = "failureReason")]
2731    pub failure_reason: Option<String>,
2732    #[serde(rename = "lastUpdated")]
2733    pub last_updated: Option<String>,
2734    #[serde(rename = "parameterContextUpdates")]
2735    pub parameter_context_updates: Option<Vec<ParameterContextUpdateEntity>>,
2736    #[serde(rename = "parameterProvider")]
2737    pub parameter_provider: Option<ParameterProviderDto>,
2738    #[serde(rename = "percentCompleted")]
2739    pub percent_completed: Option<i32>,
2740    #[serde(rename = "referencingComponents")]
2741    pub referencing_components: Option<Vec<AffectedComponentEntity>>,
2742    #[serde(rename = "requestId")]
2743    pub request_id: Option<String>,
2744    pub state: Option<String>,
2745    #[serde(rename = "submissionTime")]
2746    pub submission_time: Option<String>,
2747    #[serde(rename = "updateSteps")]
2748    pub update_steps: Option<Vec<ParameterProviderApplyParametersUpdateStepDto>>,
2749    pub uri: Option<String>,
2750}
2751
2752#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2753#[serde(rename_all = "camelCase")]
2754pub(crate) struct ParameterProviderApplyParametersRequestEntity {
2755    pub request: Option<ParameterProviderApplyParametersRequestDto>,
2756}
2757
2758#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2759#[serde(rename_all = "camelCase")]
2760pub struct ParameterProviderApplyParametersUpdateStepDto {
2761    pub complete: Option<bool>,
2762    pub description: Option<String>,
2763    #[serde(rename = "failureReason")]
2764    pub failure_reason: Option<String>,
2765}
2766
2767#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2768#[serde(rename_all = "camelCase")]
2769pub struct ParameterProviderConfigurationDto {
2770    #[serde(rename = "parameterGroupName")]
2771    pub parameter_group_name: Option<String>,
2772    #[serde(rename = "parameterProviderId")]
2773    pub parameter_provider_id: Option<String>,
2774    #[serde(rename = "parameterProviderName")]
2775    pub parameter_provider_name: Option<String>,
2776    pub synchronized: Option<bool>,
2777}
2778
2779#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2780#[serde(rename_all = "camelCase")]
2781pub struct ParameterProviderConfigurationEntity {
2782    pub component: Option<ParameterProviderConfigurationDto>,
2783    pub id: Option<String>,
2784    pub permissions: Option<PermissionsDto>,
2785}
2786
2787#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2788#[serde(rename_all = "camelCase")]
2789pub struct ParameterProviderDefinition {
2790    #[serde(rename = "additionalDetails")]
2791    pub additional_details: Option<bool>,
2792    pub artifact: Option<String>,
2793    #[serde(rename = "buildInfo")]
2794    pub build_info: Option<BuildInfo>,
2795    pub deprecated: Option<bool>,
2796    #[serde(rename = "deprecationAlternatives")]
2797    pub deprecation_alternatives: Option<Vec<String>>,
2798    #[serde(rename = "deprecationReason")]
2799    pub deprecation_reason: Option<String>,
2800    #[serde(rename = "dynamicProperties")]
2801    pub dynamic_properties: Option<Vec<DynamicProperty>>,
2802    #[serde(rename = "explicitRestrictions")]
2803    pub explicit_restrictions: Option<Vec<Restriction>>,
2804    pub group: Option<String>,
2805    #[serde(rename = "propertyDescriptors")]
2806    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
2807    #[serde(rename = "providedApiImplementations")]
2808    pub provided_api_implementations: Option<Vec<DefinedType>>,
2809    pub restricted: Option<bool>,
2810    #[serde(rename = "restrictedExplanation")]
2811    pub restricted_explanation: Option<String>,
2812    #[serde(rename = "seeAlso")]
2813    pub see_also: Option<Vec<String>>,
2814    pub stateful: Option<Stateful>,
2815    #[serde(rename = "supportsDynamicProperties")]
2816    pub supports_dynamic_properties: Option<bool>,
2817    #[serde(rename = "supportsSensitiveDynamicProperties")]
2818    pub supports_sensitive_dynamic_properties: Option<bool>,
2819    #[serde(rename = "systemResourceConsiderations")]
2820    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
2821    pub tags: Option<Vec<String>>,
2822    pub r#type: Option<String>,
2823    #[serde(rename = "typeDescription")]
2824    pub type_description: Option<String>,
2825    pub version: Option<String>,
2826}
2827
2828#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2829#[serde(rename_all = "camelCase")]
2830pub struct ParameterProviderDto {
2831    #[serde(rename = "affectedComponents")]
2832    pub affected_components: Option<Vec<AffectedComponentEntity>>,
2833    #[serde(rename = "annotationData")]
2834    pub annotation_data: Option<String>,
2835    pub bundle: Option<BundleDto>,
2836    pub comments: Option<String>,
2837    #[serde(rename = "customUiUrl")]
2838    pub custom_ui_url: Option<String>,
2839    pub deprecated: Option<bool>,
2840    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
2841    #[serde(rename = "extensionMissing")]
2842    pub extension_missing: Option<bool>,
2843    pub id: Option<String>,
2844    #[serde(rename = "multipleVersionsAvailable")]
2845    pub multiple_versions_available: Option<bool>,
2846    pub name: Option<String>,
2847    #[serde(rename = "parameterGroupConfigurations")]
2848    pub parameter_group_configurations: Option<Vec<ParameterGroupConfigurationEntity>>,
2849    #[serde(rename = "parameterStatus")]
2850    pub parameter_status: Option<Vec<ParameterStatusDto>>,
2851    #[serde(rename = "parentGroupId")]
2852    pub parent_group_id: Option<String>,
2853    #[serde(rename = "persistsState")]
2854    pub persists_state: Option<bool>,
2855    pub position: Option<PositionDto>,
2856    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
2857    #[serde(rename = "referencingParameterContexts")]
2858    pub referencing_parameter_contexts: Option<Vec<ParameterProviderReferencingComponentEntity>>,
2859    pub restricted: Option<bool>,
2860    pub r#type: Option<String>,
2861    #[serde(rename = "validationErrors")]
2862    pub validation_errors: Option<Vec<String>>,
2863    #[serde(rename = "validationStatus")]
2864    pub validation_status: Option<String>,
2865    #[serde(rename = "versionedComponentId")]
2866    pub versioned_component_id: Option<String>,
2867}
2868
2869#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2870#[serde(rename_all = "camelCase")]
2871pub struct ParameterProviderEntity {
2872    pub bulletins: Option<Vec<BulletinEntity>>,
2873    pub component: Option<ParameterProviderDto>,
2874    #[serde(rename = "disconnectedNodeAcknowledged")]
2875    pub disconnected_node_acknowledged: Option<bool>,
2876    pub id: Option<String>,
2877    pub permissions: Option<PermissionsDto>,
2878    pub position: Option<PositionDto>,
2879    pub revision: Option<RevisionDto>,
2880    pub uri: Option<String>,
2881}
2882
2883#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2884#[serde(rename_all = "camelCase")]
2885pub struct ParameterProviderParameterApplicationEntity {
2886    #[serde(rename = "disconnectedNodeAcknowledged")]
2887    pub disconnected_node_acknowledged: Option<bool>,
2888    pub id: Option<String>,
2889    #[serde(rename = "parameterGroupConfigurations")]
2890    pub parameter_group_configurations: Option<Vec<ParameterGroupConfigurationEntity>>,
2891    pub revision: Option<RevisionDto>,
2892}
2893
2894#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2895#[serde(rename_all = "camelCase")]
2896pub struct ParameterProviderParameterFetchEntity {
2897    #[serde(rename = "disconnectedNodeAcknowledged")]
2898    pub disconnected_node_acknowledged: Option<bool>,
2899    pub id: Option<String>,
2900    pub revision: Option<RevisionDto>,
2901}
2902
2903#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2904#[serde(rename_all = "camelCase")]
2905pub struct ParameterProviderReference {
2906    pub bundle: Option<Bundle>,
2907    pub identifier: Option<String>,
2908    pub name: Option<String>,
2909    pub r#type: Option<String>,
2910}
2911
2912#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2913#[serde(rename_all = "camelCase")]
2914pub struct ParameterProviderReferencingComponentDto {
2915    pub id: Option<String>,
2916    pub name: Option<String>,
2917}
2918
2919#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2920#[serde(rename_all = "camelCase")]
2921pub struct ParameterProviderReferencingComponentEntity {
2922    pub bulletins: Option<Vec<BulletinEntity>>,
2923    pub component: Option<ParameterProviderReferencingComponentDto>,
2924    #[serde(rename = "disconnectedNodeAcknowledged")]
2925    pub disconnected_node_acknowledged: Option<bool>,
2926    pub id: Option<String>,
2927    pub permissions: Option<PermissionsDto>,
2928    pub position: Option<PositionDto>,
2929    pub revision: Option<RevisionDto>,
2930    pub uri: Option<String>,
2931}
2932
2933#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2934#[serde(rename_all = "camelCase")]
2935pub struct ParameterProviderReferencingComponentsEntity {
2936    #[serde(rename = "parameterProviderReferencingComponents")]
2937    pub parameter_provider_referencing_components:
2938        Option<Vec<ParameterProviderReferencingComponentEntity>>,
2939}
2940
2941#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2942#[serde(rename_all = "camelCase")]
2943pub struct ParameterProviderTypesEntity {
2944    #[serde(rename = "parameterProviderTypes")]
2945    pub parameter_provider_types: Option<Vec<DocumentedTypeDto>>,
2946}
2947
2948#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2949#[serde(rename_all = "camelCase")]
2950pub struct ParameterProvidersEntity {
2951    #[serde(rename = "currentTime")]
2952    pub current_time: Option<String>,
2953    #[serde(rename = "parameterProviders")]
2954    pub parameter_providers: Option<Vec<ParameterProviderEntity>>,
2955}
2956
2957#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2958#[serde(rename_all = "camelCase")]
2959pub struct ParameterStatusDto {
2960    pub parameter: Option<ParameterEntity>,
2961    pub status: Option<String>,
2962}
2963
2964#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2965#[serde(rename_all = "camelCase")]
2966pub struct PasteRequestEntity {
2967    #[serde(rename = "copyResponse")]
2968    pub copy_response: Option<CopyResponseEntity>,
2969    #[serde(rename = "disconnectedNodeAcknowledged")]
2970    pub disconnected_node_acknowledged: Option<bool>,
2971    pub revision: Option<RevisionDto>,
2972}
2973
2974#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2975#[serde(rename_all = "camelCase")]
2976pub struct PasteResponseEntity {
2977    pub flow: Option<FlowDto>,
2978    pub revision: Option<RevisionDto>,
2979}
2980
2981#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2982#[serde(rename_all = "camelCase")]
2983pub struct PeerDto {
2984    #[serde(rename = "flowFileCount")]
2985    pub flow_file_count: Option<i32>,
2986    pub hostname: Option<String>,
2987    pub port: Option<i32>,
2988    pub secure: Option<bool>,
2989}
2990
2991#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2992#[serde(rename_all = "camelCase")]
2993pub struct PeersEntity {
2994    pub peers: Option<Vec<PeerDto>>,
2995}
2996
2997#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2998#[serde(rename_all = "camelCase")]
2999pub struct PermissionsDto {
3000    #[serde(rename = "canRead")]
3001    pub can_read: Option<bool>,
3002    #[serde(rename = "canWrite")]
3003    pub can_write: Option<bool>,
3004}
3005
3006#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3007#[serde(rename_all = "camelCase")]
3008pub struct PortDto {
3009    #[serde(rename = "allowRemoteAccess")]
3010    pub allow_remote_access: Option<bool>,
3011    pub comments: Option<String>,
3012    #[serde(rename = "concurrentlySchedulableTaskCount")]
3013    pub concurrently_schedulable_task_count: Option<i32>,
3014    pub id: Option<String>,
3015    pub name: Option<String>,
3016    #[serde(rename = "parentGroupId")]
3017    pub parent_group_id: Option<String>,
3018    #[serde(rename = "portFunction")]
3019    pub port_function: Option<String>,
3020    pub position: Option<PositionDto>,
3021    pub state: Option<String>,
3022    pub transmitting: Option<bool>,
3023    pub r#type: Option<String>,
3024    #[serde(rename = "validationErrors")]
3025    pub validation_errors: Option<Vec<String>>,
3026    #[serde(rename = "versionedComponentId")]
3027    pub versioned_component_id: Option<String>,
3028}
3029
3030#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3031#[serde(rename_all = "camelCase")]
3032pub struct PortEntity {
3033    #[serde(rename = "allowRemoteAccess")]
3034    pub allow_remote_access: Option<bool>,
3035    pub bulletins: Option<Vec<BulletinEntity>>,
3036    pub component: Option<PortDto>,
3037    #[serde(rename = "disconnectedNodeAcknowledged")]
3038    pub disconnected_node_acknowledged: Option<bool>,
3039    pub id: Option<String>,
3040    #[serde(rename = "operatePermissions")]
3041    pub operate_permissions: Option<PermissionsDto>,
3042    pub permissions: Option<PermissionsDto>,
3043    #[serde(rename = "portType")]
3044    pub port_type: Option<String>,
3045    pub position: Option<PositionDto>,
3046    pub revision: Option<RevisionDto>,
3047    pub status: Option<PortStatusDto>,
3048    pub uri: Option<String>,
3049}
3050
3051#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3052#[serde(rename_all = "camelCase")]
3053pub struct PortRunStatusEntity {
3054    #[serde(rename = "disconnectedNodeAcknowledged")]
3055    pub disconnected_node_acknowledged: Option<bool>,
3056    pub revision: Option<RevisionDto>,
3057    pub state: Option<String>,
3058}
3059
3060#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3061#[serde(rename_all = "camelCase")]
3062pub struct PortStatusDto {
3063    #[serde(rename = "aggregateSnapshot")]
3064    pub aggregate_snapshot: Option<PortStatusSnapshotDto>,
3065    #[serde(rename = "groupId")]
3066    pub group_id: Option<String>,
3067    pub id: Option<String>,
3068    pub name: Option<String>,
3069    #[serde(rename = "nodeSnapshots")]
3070    pub node_snapshots: Option<Vec<NodePortStatusSnapshotDto>>,
3071    #[serde(rename = "runStatus")]
3072    pub run_status: Option<String>,
3073    #[serde(rename = "statsLastRefreshed")]
3074    pub stats_last_refreshed: Option<String>,
3075    pub transmitting: Option<bool>,
3076}
3077
3078#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3079#[serde(rename_all = "camelCase")]
3080pub struct PortStatusEntity {
3081    #[serde(rename = "canRead")]
3082    pub can_read: Option<bool>,
3083    #[serde(rename = "portStatus")]
3084    pub port_status: Option<PortStatusDto>,
3085}
3086
3087#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3088#[serde(rename_all = "camelCase")]
3089pub struct PortStatusSnapshotDto {
3090    #[serde(rename = "activeThreadCount")]
3091    pub active_thread_count: Option<i32>,
3092    #[serde(rename = "bytesIn")]
3093    pub bytes_in: Option<i64>,
3094    #[serde(rename = "bytesOut")]
3095    pub bytes_out: Option<i64>,
3096    #[serde(rename = "flowFilesIn")]
3097    pub flow_files_in: Option<i32>,
3098    #[serde(rename = "flowFilesOut")]
3099    pub flow_files_out: Option<i32>,
3100    #[serde(rename = "groupId")]
3101    pub group_id: Option<String>,
3102    pub id: Option<String>,
3103    pub input: Option<String>,
3104    pub name: Option<String>,
3105    pub output: Option<String>,
3106    #[serde(rename = "runStatus")]
3107    pub run_status: Option<String>,
3108    pub transmitting: Option<bool>,
3109}
3110
3111#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3112#[serde(rename_all = "camelCase")]
3113pub struct PortStatusSnapshotEntity {
3114    #[serde(rename = "canRead")]
3115    pub can_read: Option<bool>,
3116    pub id: Option<String>,
3117    #[serde(rename = "portStatusSnapshot")]
3118    pub port_status_snapshot: Option<PortStatusSnapshotDto>,
3119}
3120
3121#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3122#[serde(rename_all = "camelCase")]
3123pub struct Position {
3124    pub x: Option<f64>,
3125    pub y: Option<f64>,
3126}
3127
3128#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3129#[serde(rename_all = "camelCase")]
3130pub struct PositionDto {
3131    pub x: Option<f64>,
3132    pub y: Option<f64>,
3133}
3134
3135#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3136#[serde(rename_all = "camelCase")]
3137pub struct PreviousValueDto {
3138    #[serde(rename = "previousValue")]
3139    pub previous_value: Option<String>,
3140    pub timestamp: Option<String>,
3141    #[serde(rename = "userIdentity")]
3142    pub user_identity: Option<String>,
3143}
3144
3145#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3146#[serde(rename_all = "camelCase")]
3147pub struct PrioritizerTypesEntity {
3148    #[serde(rename = "prioritizerTypes")]
3149    pub prioritizer_types: Option<Vec<DocumentedTypeDto>>,
3150}
3151
3152#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3153#[serde(rename_all = "camelCase")]
3154pub struct ProcessGroupDto {
3155    #[serde(rename = "activeRemotePortCount")]
3156    pub active_remote_port_count: Option<i32>,
3157    pub comments: Option<String>,
3158    pub contents: Option<FlowSnippetDto>,
3159    #[serde(rename = "defaultBackPressureDataSizeThreshold")]
3160    pub default_back_pressure_data_size_threshold: Option<String>,
3161    #[serde(rename = "defaultBackPressureObjectThreshold")]
3162    pub default_back_pressure_object_threshold: Option<i64>,
3163    #[serde(rename = "defaultFlowFileExpiration")]
3164    pub default_flow_file_expiration: Option<String>,
3165    #[serde(rename = "disabledCount")]
3166    pub disabled_count: Option<i32>,
3167    #[serde(rename = "executionEngine")]
3168    pub execution_engine: Option<String>,
3169    #[serde(rename = "flowfileConcurrency")]
3170    pub flowfile_concurrency: Option<String>,
3171    #[serde(rename = "flowfileOutboundPolicy")]
3172    pub flowfile_outbound_policy: Option<String>,
3173    pub id: Option<String>,
3174    #[serde(rename = "inactiveRemotePortCount")]
3175    pub inactive_remote_port_count: Option<i32>,
3176    #[serde(rename = "inputPortCount")]
3177    pub input_port_count: Option<i32>,
3178    #[serde(rename = "invalidCount")]
3179    pub invalid_count: Option<i32>,
3180    #[serde(rename = "localInputPortCount")]
3181    pub local_input_port_count: Option<i32>,
3182    #[serde(rename = "localOutputPortCount")]
3183    pub local_output_port_count: Option<i32>,
3184    #[serde(rename = "locallyModifiedAndStaleCount")]
3185    pub locally_modified_and_stale_count: Option<i32>,
3186    #[serde(rename = "locallyModifiedCount")]
3187    pub locally_modified_count: Option<i32>,
3188    #[serde(rename = "logFileSuffix")]
3189    pub log_file_suffix: Option<String>,
3190    #[serde(rename = "maxConcurrentTasks")]
3191    pub max_concurrent_tasks: Option<i32>,
3192    pub name: Option<String>,
3193    #[serde(rename = "outputPortCount")]
3194    pub output_port_count: Option<i32>,
3195    #[serde(rename = "parameterContext")]
3196    pub parameter_context: Option<ParameterContextReferenceEntity>,
3197    #[serde(rename = "parentGroupId")]
3198    pub parent_group_id: Option<String>,
3199    pub position: Option<PositionDto>,
3200    #[serde(rename = "publicInputPortCount")]
3201    pub public_input_port_count: Option<i32>,
3202    #[serde(rename = "publicOutputPortCount")]
3203    pub public_output_port_count: Option<i32>,
3204    #[serde(rename = "runningCount")]
3205    pub running_count: Option<i32>,
3206    #[serde(rename = "staleCount")]
3207    pub stale_count: Option<i32>,
3208    #[serde(rename = "statelessFlowTimeout")]
3209    pub stateless_flow_timeout: Option<String>,
3210    #[serde(rename = "statelessGroupScheduledState")]
3211    pub stateless_group_scheduled_state: Option<String>,
3212    #[serde(rename = "stoppedCount")]
3213    pub stopped_count: Option<i32>,
3214    #[serde(rename = "syncFailureCount")]
3215    pub sync_failure_count: Option<i32>,
3216    #[serde(rename = "upToDateCount")]
3217    pub up_to_date_count: Option<i32>,
3218    #[serde(rename = "versionControlInformation")]
3219    pub version_control_information: Option<VersionControlInformationDto>,
3220    #[serde(rename = "versionedComponentId")]
3221    pub versioned_component_id: Option<String>,
3222}
3223
3224#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3225#[serde(rename_all = "camelCase")]
3226pub struct ProcessGroupEntity {
3227    #[serde(rename = "activeRemotePortCount")]
3228    pub active_remote_port_count: Option<i32>,
3229    pub bulletins: Option<Vec<BulletinEntity>>,
3230    pub component: Option<ProcessGroupDto>,
3231    #[serde(rename = "disabledCount")]
3232    pub disabled_count: Option<i32>,
3233    #[serde(rename = "disconnectedNodeAcknowledged")]
3234    pub disconnected_node_acknowledged: Option<bool>,
3235    pub id: Option<String>,
3236    #[serde(rename = "inactiveRemotePortCount")]
3237    pub inactive_remote_port_count: Option<i32>,
3238    #[serde(rename = "inputPortCount")]
3239    pub input_port_count: Option<i32>,
3240    #[serde(rename = "invalidCount")]
3241    pub invalid_count: Option<i32>,
3242    #[serde(rename = "localInputPortCount")]
3243    pub local_input_port_count: Option<i32>,
3244    #[serde(rename = "localOutputPortCount")]
3245    pub local_output_port_count: Option<i32>,
3246    #[serde(rename = "locallyModifiedAndStaleCount")]
3247    pub locally_modified_and_stale_count: Option<i32>,
3248    #[serde(rename = "locallyModifiedCount")]
3249    pub locally_modified_count: Option<i32>,
3250    #[serde(rename = "outputPortCount")]
3251    pub output_port_count: Option<i32>,
3252    #[serde(rename = "parameterContext")]
3253    pub parameter_context: Option<ParameterContextReferenceEntity>,
3254    pub permissions: Option<PermissionsDto>,
3255    pub position: Option<PositionDto>,
3256    #[serde(rename = "processGroupUpdateStrategy")]
3257    pub process_group_update_strategy: Option<String>,
3258    #[serde(rename = "publicInputPortCount")]
3259    pub public_input_port_count: Option<i32>,
3260    #[serde(rename = "publicOutputPortCount")]
3261    pub public_output_port_count: Option<i32>,
3262    pub revision: Option<RevisionDto>,
3263    #[serde(rename = "runningCount")]
3264    pub running_count: Option<i32>,
3265    #[serde(rename = "staleCount")]
3266    pub stale_count: Option<i32>,
3267    pub status: Option<ProcessGroupStatusDto>,
3268    #[serde(rename = "stoppedCount")]
3269    pub stopped_count: Option<i32>,
3270    #[serde(rename = "syncFailureCount")]
3271    pub sync_failure_count: Option<i32>,
3272    #[serde(rename = "upToDateCount")]
3273    pub up_to_date_count: Option<i32>,
3274    pub uri: Option<String>,
3275    #[serde(rename = "versionedFlowSnapshot")]
3276    pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
3277    #[serde(rename = "versionedFlowState")]
3278    pub versioned_flow_state: Option<String>,
3279}
3280
3281#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3282#[serde(rename_all = "camelCase")]
3283pub struct ProcessGroupFlowDto {
3284    pub breadcrumb: Option<FlowBreadcrumbEntity>,
3285    pub flow: Option<FlowDto>,
3286    pub id: Option<String>,
3287    #[serde(rename = "lastRefreshed")]
3288    pub last_refreshed: Option<String>,
3289    #[serde(rename = "parameterContext")]
3290    pub parameter_context: Option<ParameterContextReferenceEntity>,
3291    #[serde(rename = "parentGroupId")]
3292    pub parent_group_id: Option<String>,
3293    pub uri: Option<String>,
3294}
3295
3296#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3297#[serde(rename_all = "camelCase")]
3298pub struct ProcessGroupFlowEntity {
3299    pub permissions: Option<PermissionsDto>,
3300    #[serde(rename = "processGroupFlow")]
3301    pub process_group_flow: Option<ProcessGroupFlowDto>,
3302    pub revision: Option<RevisionDto>,
3303}
3304
3305#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3306#[serde(rename_all = "camelCase")]
3307pub struct ProcessGroupImportEntity {
3308    #[serde(rename = "disconnectedNodeAcknowledged")]
3309    pub disconnected_node_acknowledged: Option<bool>,
3310    #[serde(rename = "processGroupRevision")]
3311    pub process_group_revision: Option<RevisionDto>,
3312    #[serde(rename = "versionedFlowSnapshot")]
3313    pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
3314}
3315
3316#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3317#[serde(rename_all = "camelCase")]
3318pub struct ProcessGroupNameDto {
3319    pub id: Option<String>,
3320    pub name: Option<String>,
3321}
3322
3323#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3324#[serde(rename_all = "camelCase")]
3325pub struct ProcessGroupReplaceRequestDto {
3326    pub complete: Option<bool>,
3327    #[serde(rename = "failureReason")]
3328    pub failure_reason: Option<String>,
3329    #[serde(rename = "lastUpdated")]
3330    pub last_updated: Option<String>,
3331    #[serde(rename = "percentCompleted")]
3332    pub percent_completed: Option<i32>,
3333    #[serde(rename = "processGroupId")]
3334    pub process_group_id: Option<String>,
3335    #[serde(rename = "requestId")]
3336    pub request_id: Option<String>,
3337    pub state: Option<String>,
3338    pub uri: Option<String>,
3339}
3340
3341#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3342#[serde(rename_all = "camelCase")]
3343pub struct ProcessGroupReplaceRequestEntity {
3344    #[serde(rename = "processGroupRevision")]
3345    pub process_group_revision: Option<RevisionDto>,
3346    pub request: Option<ProcessGroupReplaceRequestDto>,
3347    #[serde(rename = "versionedFlowSnapshot")]
3348    pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
3349}
3350
3351#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3352#[serde(rename_all = "camelCase")]
3353pub struct ProcessGroupStatusDto {
3354    #[serde(rename = "aggregateSnapshot")]
3355    pub aggregate_snapshot: Option<ProcessGroupStatusSnapshotDto>,
3356    pub id: Option<String>,
3357    pub name: Option<String>,
3358    #[serde(rename = "nodeSnapshots")]
3359    pub node_snapshots: Option<Vec<NodeProcessGroupStatusSnapshotDto>>,
3360    #[serde(rename = "statsLastRefreshed")]
3361    pub stats_last_refreshed: Option<String>,
3362}
3363
3364#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3365#[serde(rename_all = "camelCase")]
3366pub struct ProcessGroupStatusEntity {
3367    #[serde(rename = "canRead")]
3368    pub can_read: Option<bool>,
3369    #[serde(rename = "processGroupStatus")]
3370    pub process_group_status: Option<ProcessGroupStatusDto>,
3371}
3372
3373#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3374#[serde(rename_all = "camelCase")]
3375pub struct ProcessGroupStatusSnapshotDto {
3376    #[serde(rename = "activeThreadCount")]
3377    pub active_thread_count: Option<i32>,
3378    #[serde(rename = "bytesIn")]
3379    pub bytes_in: Option<i64>,
3380    #[serde(rename = "bytesOut")]
3381    pub bytes_out: Option<i64>,
3382    #[serde(rename = "bytesQueued")]
3383    pub bytes_queued: Option<i64>,
3384    #[serde(rename = "bytesRead")]
3385    pub bytes_read: Option<i64>,
3386    #[serde(rename = "bytesReceived")]
3387    pub bytes_received: Option<i64>,
3388    #[serde(rename = "bytesSent")]
3389    pub bytes_sent: Option<i64>,
3390    #[serde(rename = "bytesTransferred")]
3391    pub bytes_transferred: Option<i64>,
3392    #[serde(rename = "bytesWritten")]
3393    pub bytes_written: Option<i64>,
3394    #[serde(rename = "connectionStatusSnapshots")]
3395    pub connection_status_snapshots: Option<Vec<ConnectionStatusSnapshotEntity>>,
3396    #[serde(rename = "flowFilesIn")]
3397    pub flow_files_in: Option<i32>,
3398    #[serde(rename = "flowFilesOut")]
3399    pub flow_files_out: Option<i32>,
3400    #[serde(rename = "flowFilesQueued")]
3401    pub flow_files_queued: Option<i32>,
3402    #[serde(rename = "flowFilesReceived")]
3403    pub flow_files_received: Option<i32>,
3404    #[serde(rename = "flowFilesSent")]
3405    pub flow_files_sent: Option<i32>,
3406    #[serde(rename = "flowFilesTransferred")]
3407    pub flow_files_transferred: Option<i32>,
3408    pub id: Option<String>,
3409    pub input: Option<String>,
3410    #[serde(rename = "inputPortStatusSnapshots")]
3411    pub input_port_status_snapshots: Option<Vec<PortStatusSnapshotEntity>>,
3412    pub name: Option<String>,
3413    pub output: Option<String>,
3414    #[serde(rename = "outputPortStatusSnapshots")]
3415    pub output_port_status_snapshots: Option<Vec<PortStatusSnapshotEntity>>,
3416    #[serde(rename = "processGroupStatusSnapshots")]
3417    pub process_group_status_snapshots: Option<Vec<ProcessGroupStatusSnapshotEntity>>,
3418    #[serde(rename = "processingNanos")]
3419    pub processing_nanos: Option<i64>,
3420    #[serde(rename = "processingPerformanceStatus")]
3421    pub processing_performance_status: Option<ProcessingPerformanceStatusDto>,
3422    #[serde(rename = "processorStatusSnapshots")]
3423    pub processor_status_snapshots: Option<Vec<ProcessorStatusSnapshotEntity>>,
3424    pub queued: Option<String>,
3425    #[serde(rename = "queuedCount")]
3426    pub queued_count: Option<String>,
3427    #[serde(rename = "queuedSize")]
3428    pub queued_size: Option<String>,
3429    pub read: Option<String>,
3430    pub received: Option<String>,
3431    #[serde(rename = "remoteProcessGroupStatusSnapshots")]
3432    pub remote_process_group_status_snapshots: Option<Vec<RemoteProcessGroupStatusSnapshotEntity>>,
3433    pub sent: Option<String>,
3434    #[serde(rename = "statelessActiveThreadCount")]
3435    pub stateless_active_thread_count: Option<i32>,
3436    #[serde(rename = "terminatedThreadCount")]
3437    pub terminated_thread_count: Option<i32>,
3438    pub transferred: Option<String>,
3439    #[serde(rename = "versionedFlowState")]
3440    pub versioned_flow_state: Option<String>,
3441    pub written: Option<String>,
3442}
3443
3444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3445#[serde(rename_all = "camelCase")]
3446pub struct ProcessGroupStatusSnapshotEntity {
3447    #[serde(rename = "canRead")]
3448    pub can_read: Option<bool>,
3449    pub id: Option<String>,
3450    #[serde(rename = "processGroupStatusSnapshot")]
3451    pub process_group_status_snapshot: Option<ProcessGroupStatusSnapshotDto>,
3452}
3453
3454#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3455#[serde(rename_all = "camelCase")]
3456pub struct ProcessGroupUploadEntity {
3457    #[serde(rename = "disconnectedNodeAcknowledged")]
3458    pub disconnected_node_acknowledged: Option<bool>,
3459    #[serde(rename = "flowSnapshot")]
3460    pub flow_snapshot: Option<RegisteredFlowSnapshot>,
3461    #[serde(rename = "groupId")]
3462    pub group_id: Option<String>,
3463    #[serde(rename = "groupName")]
3464    pub group_name: Option<String>,
3465    #[serde(rename = "positionDTO")]
3466    pub position_d_t_o: Option<PositionDto>,
3467    #[serde(rename = "revisionDTO")]
3468    pub revision_d_t_o: Option<RevisionDto>,
3469}
3470
3471#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3472#[serde(rename_all = "camelCase")]
3473pub struct ProcessGroupsEntity {
3474    #[serde(rename = "processGroups")]
3475    pub process_groups: Option<Vec<ProcessGroupEntity>>,
3476}
3477
3478#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3479#[serde(rename_all = "camelCase")]
3480pub struct ProcessingPerformanceStatusDto {
3481    #[serde(rename = "contentReadDuration")]
3482    pub content_read_duration: Option<i64>,
3483    #[serde(rename = "contentWriteDuration")]
3484    pub content_write_duration: Option<i64>,
3485    #[serde(rename = "cpuDuration")]
3486    pub cpu_duration: Option<i64>,
3487    #[serde(rename = "garbageCollectionDuration")]
3488    pub garbage_collection_duration: Option<i64>,
3489    pub identifier: Option<String>,
3490    #[serde(rename = "sessionCommitDuration")]
3491    pub session_commit_duration: Option<i64>,
3492}
3493
3494#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3495#[serde(rename_all = "camelCase")]
3496pub struct ProcessorConfigDto {
3497    #[serde(rename = "annotationData")]
3498    pub annotation_data: Option<String>,
3499    #[serde(rename = "autoTerminatedRelationships")]
3500    pub auto_terminated_relationships: Option<Vec<String>>,
3501    #[serde(rename = "backoffMechanism")]
3502    pub backoff_mechanism: Option<String>,
3503    #[serde(rename = "bulletinLevel")]
3504    pub bulletin_level: Option<String>,
3505    pub comments: Option<String>,
3506    #[serde(rename = "concurrentlySchedulableTaskCount")]
3507    pub concurrently_schedulable_task_count: Option<i32>,
3508    #[serde(rename = "customUiUrl")]
3509    pub custom_ui_url: Option<String>,
3510    #[serde(rename = "defaultConcurrentTasks")]
3511    pub default_concurrent_tasks: Option<std::collections::HashMap<String, Option<String>>>,
3512    #[serde(rename = "defaultSchedulingPeriod")]
3513    pub default_scheduling_period: Option<std::collections::HashMap<String, Option<String>>>,
3514    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
3515    #[serde(rename = "executionNode")]
3516    pub execution_node: Option<String>,
3517    #[serde(rename = "lossTolerant")]
3518    pub loss_tolerant: Option<bool>,
3519    #[serde(rename = "maxBackoffPeriod")]
3520    pub max_backoff_period: Option<String>,
3521    #[serde(rename = "penaltyDuration")]
3522    pub penalty_duration: Option<String>,
3523    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
3524    #[serde(rename = "retriedRelationships")]
3525    pub retried_relationships: Option<Vec<String>>,
3526    #[serde(rename = "retryCount")]
3527    pub retry_count: Option<i32>,
3528    #[serde(rename = "runDurationMillis")]
3529    pub run_duration_millis: Option<i64>,
3530    #[serde(rename = "schedulingPeriod")]
3531    pub scheduling_period: Option<String>,
3532    #[serde(rename = "schedulingStrategy")]
3533    pub scheduling_strategy: Option<String>,
3534    #[serde(rename = "sensitiveDynamicPropertyNames")]
3535    pub sensitive_dynamic_property_names: Option<Vec<String>>,
3536    #[serde(rename = "yieldDuration")]
3537    pub yield_duration: Option<String>,
3538}
3539
3540#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3541#[serde(rename_all = "camelCase")]
3542pub struct ProcessorConfiguration {
3543    pub configuration: Option<String>,
3544    #[serde(rename = "processorClassName")]
3545    pub processor_class_name: Option<String>,
3546}
3547
3548#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3549#[serde(rename_all = "camelCase")]
3550pub struct ProcessorDefinition {
3551    #[serde(rename = "additionalDetails")]
3552    pub additional_details: Option<bool>,
3553    pub artifact: Option<String>,
3554    #[serde(rename = "buildInfo")]
3555    pub build_info: Option<BuildInfo>,
3556    #[serde(rename = "defaultBulletinLevel")]
3557    pub default_bulletin_level: Option<String>,
3558    #[serde(rename = "defaultConcurrentTasksBySchedulingStrategy")]
3559    pub default_concurrent_tasks_by_scheduling_strategy:
3560        Option<std::collections::HashMap<String, Option<i32>>>,
3561    #[serde(rename = "defaultPenaltyDuration")]
3562    pub default_penalty_duration: Option<String>,
3563    #[serde(rename = "defaultSchedulingPeriodBySchedulingStrategy")]
3564    pub default_scheduling_period_by_scheduling_strategy:
3565        Option<std::collections::HashMap<String, Option<String>>>,
3566    #[serde(rename = "defaultSchedulingStrategy")]
3567    pub default_scheduling_strategy: Option<String>,
3568    #[serde(rename = "defaultYieldDuration")]
3569    pub default_yield_duration: Option<String>,
3570    pub deprecated: Option<bool>,
3571    #[serde(rename = "deprecationAlternatives")]
3572    pub deprecation_alternatives: Option<Vec<String>>,
3573    #[serde(rename = "deprecationReason")]
3574    pub deprecation_reason: Option<String>,
3575    #[serde(rename = "dynamicProperties")]
3576    pub dynamic_properties: Option<Vec<DynamicProperty>>,
3577    #[serde(rename = "dynamicRelationship")]
3578    pub dynamic_relationship: Option<DynamicRelationship>,
3579    #[serde(rename = "explicitRestrictions")]
3580    pub explicit_restrictions: Option<Vec<Restriction>>,
3581    pub group: Option<String>,
3582    #[serde(rename = "inputRequirement")]
3583    pub input_requirement: Option<String>,
3584    #[serde(rename = "multiProcessorUseCases")]
3585    pub multi_processor_use_cases: Option<Vec<MultiProcessorUseCase>>,
3586    #[serde(rename = "primaryNodeOnly")]
3587    pub primary_node_only: Option<bool>,
3588    #[serde(rename = "propertyDescriptors")]
3589    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
3590    #[serde(rename = "providedApiImplementations")]
3591    pub provided_api_implementations: Option<Vec<DefinedType>>,
3592    #[serde(rename = "readsAttributes")]
3593    pub reads_attributes: Option<Vec<Attribute>>,
3594    pub restricted: Option<bool>,
3595    #[serde(rename = "restrictedExplanation")]
3596    pub restricted_explanation: Option<String>,
3597    #[serde(rename = "seeAlso")]
3598    pub see_also: Option<Vec<String>>,
3599    #[serde(rename = "sideEffectFree")]
3600    pub side_effect_free: Option<bool>,
3601    pub stateful: Option<Stateful>,
3602    #[serde(rename = "supportedRelationships")]
3603    pub supported_relationships: Option<Vec<Relationship>>,
3604    #[serde(rename = "supportedSchedulingStrategies")]
3605    pub supported_scheduling_strategies: Option<Vec<String>>,
3606    #[serde(rename = "supportsBatching")]
3607    pub supports_batching: Option<bool>,
3608    #[serde(rename = "supportsDynamicProperties")]
3609    pub supports_dynamic_properties: Option<bool>,
3610    #[serde(rename = "supportsDynamicRelationships")]
3611    pub supports_dynamic_relationships: Option<bool>,
3612    #[serde(rename = "supportsSensitiveDynamicProperties")]
3613    pub supports_sensitive_dynamic_properties: Option<bool>,
3614    #[serde(rename = "systemResourceConsiderations")]
3615    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
3616    pub tags: Option<Vec<String>>,
3617    #[serde(rename = "triggerSerially")]
3618    pub trigger_serially: Option<bool>,
3619    #[serde(rename = "triggerWhenAnyDestinationAvailable")]
3620    pub trigger_when_any_destination_available: Option<bool>,
3621    #[serde(rename = "triggerWhenEmpty")]
3622    pub trigger_when_empty: Option<bool>,
3623    pub r#type: Option<String>,
3624    #[serde(rename = "typeDescription")]
3625    pub type_description: Option<String>,
3626    #[serde(rename = "useCases")]
3627    pub use_cases: Option<Vec<UseCase>>,
3628    pub version: Option<String>,
3629    #[serde(rename = "writesAttributes")]
3630    pub writes_attributes: Option<Vec<Attribute>>,
3631}
3632
3633#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3634#[serde(rename_all = "camelCase")]
3635pub struct ProcessorDto {
3636    pub bundle: Option<BundleDto>,
3637    pub config: Option<ProcessorConfigDto>,
3638    pub deprecated: Option<bool>,
3639    pub description: Option<String>,
3640    #[serde(rename = "executionNodeRestricted")]
3641    pub execution_node_restricted: Option<bool>,
3642    #[serde(rename = "extensionMissing")]
3643    pub extension_missing: Option<bool>,
3644    pub id: Option<String>,
3645    #[serde(rename = "inputRequirement")]
3646    pub input_requirement: Option<String>,
3647    #[serde(rename = "multipleVersionsAvailable")]
3648    pub multiple_versions_available: Option<bool>,
3649    pub name: Option<String>,
3650    #[serde(rename = "parentGroupId")]
3651    pub parent_group_id: Option<String>,
3652    #[serde(rename = "persistsState")]
3653    pub persists_state: Option<bool>,
3654    #[serde(rename = "physicalState")]
3655    pub physical_state: Option<String>,
3656    pub position: Option<PositionDto>,
3657    pub relationships: Option<Vec<RelationshipDto>>,
3658    pub restricted: Option<bool>,
3659    pub state: Option<String>,
3660    pub style: Option<std::collections::HashMap<String, Option<String>>>,
3661    #[serde(rename = "supportsBatching")]
3662    pub supports_batching: Option<bool>,
3663    #[serde(rename = "supportsParallelProcessing")]
3664    pub supports_parallel_processing: Option<bool>,
3665    #[serde(rename = "supportsSensitiveDynamicProperties")]
3666    pub supports_sensitive_dynamic_properties: Option<bool>,
3667    pub r#type: Option<String>,
3668    #[serde(rename = "validationErrors")]
3669    pub validation_errors: Option<Vec<String>>,
3670    #[serde(rename = "validationStatus")]
3671    pub validation_status: Option<String>,
3672    #[serde(rename = "versionedComponentId")]
3673    pub versioned_component_id: Option<String>,
3674}
3675
3676#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3677#[serde(rename_all = "camelCase")]
3678pub struct ProcessorEntity {
3679    pub bulletins: Option<Vec<BulletinEntity>>,
3680    pub component: Option<ProcessorDto>,
3681    #[serde(rename = "disconnectedNodeAcknowledged")]
3682    pub disconnected_node_acknowledged: Option<bool>,
3683    pub id: Option<String>,
3684    #[serde(rename = "inputRequirement")]
3685    pub input_requirement: Option<String>,
3686    #[serde(rename = "operatePermissions")]
3687    pub operate_permissions: Option<PermissionsDto>,
3688    pub permissions: Option<PermissionsDto>,
3689    #[serde(rename = "physicalState")]
3690    pub physical_state: Option<String>,
3691    pub position: Option<PositionDto>,
3692    pub revision: Option<RevisionDto>,
3693    pub status: Option<ProcessorStatusDto>,
3694    pub uri: Option<String>,
3695}
3696
3697#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3698#[serde(rename_all = "camelCase")]
3699pub struct ProcessorRunStatusDetailsDto {
3700    #[serde(rename = "activeThreadCount")]
3701    pub active_thread_count: Option<i32>,
3702    pub id: Option<String>,
3703    pub name: Option<String>,
3704    #[serde(rename = "runStatus")]
3705    pub run_status: Option<String>,
3706    #[serde(rename = "validationErrors")]
3707    pub validation_errors: Option<Vec<String>>,
3708}
3709
3710#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3711#[serde(rename_all = "camelCase")]
3712pub struct ProcessorRunStatusDetailsEntity {
3713    pub permissions: Option<PermissionsDto>,
3714    pub revision: Option<RevisionDto>,
3715    #[serde(rename = "runStatusDetails")]
3716    pub run_status_details: Option<ProcessorRunStatusDetailsDto>,
3717}
3718
3719#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3720#[serde(rename_all = "camelCase")]
3721pub struct ProcessorRunStatusEntity {
3722    #[serde(rename = "disconnectedNodeAcknowledged")]
3723    pub disconnected_node_acknowledged: Option<bool>,
3724    pub revision: Option<RevisionDto>,
3725    pub state: Option<String>,
3726}
3727
3728#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3729#[serde(rename_all = "camelCase")]
3730pub struct ProcessorStatusDto {
3731    #[serde(rename = "aggregateSnapshot")]
3732    pub aggregate_snapshot: Option<ProcessorStatusSnapshotDto>,
3733    #[serde(rename = "groupId")]
3734    pub group_id: Option<String>,
3735    pub id: Option<String>,
3736    pub name: Option<String>,
3737    #[serde(rename = "nodeSnapshots")]
3738    pub node_snapshots: Option<Vec<NodeProcessorStatusSnapshotDto>>,
3739    #[serde(rename = "runStatus")]
3740    pub run_status: Option<String>,
3741    #[serde(rename = "statsLastRefreshed")]
3742    pub stats_last_refreshed: Option<String>,
3743    pub r#type: Option<String>,
3744}
3745
3746#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3747#[serde(rename_all = "camelCase")]
3748pub struct ProcessorStatusEntity {
3749    #[serde(rename = "canRead")]
3750    pub can_read: Option<bool>,
3751    #[serde(rename = "processorStatus")]
3752    pub processor_status: Option<ProcessorStatusDto>,
3753}
3754
3755#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3756#[serde(rename_all = "camelCase")]
3757pub struct ProcessorStatusSnapshotDto {
3758    #[serde(rename = "activeThreadCount")]
3759    pub active_thread_count: Option<i32>,
3760    #[serde(rename = "bytesIn")]
3761    pub bytes_in: Option<i64>,
3762    #[serde(rename = "bytesOut")]
3763    pub bytes_out: Option<i64>,
3764    #[serde(rename = "bytesRead")]
3765    pub bytes_read: Option<i64>,
3766    #[serde(rename = "bytesWritten")]
3767    pub bytes_written: Option<i64>,
3768    #[serde(rename = "executionNode")]
3769    pub execution_node: Option<String>,
3770    #[serde(rename = "flowFilesIn")]
3771    pub flow_files_in: Option<i32>,
3772    #[serde(rename = "flowFilesOut")]
3773    pub flow_files_out: Option<i32>,
3774    #[serde(rename = "groupId")]
3775    pub group_id: Option<String>,
3776    pub id: Option<String>,
3777    pub input: Option<String>,
3778    pub name: Option<String>,
3779    pub output: Option<String>,
3780    #[serde(rename = "processingPerformanceStatus")]
3781    pub processing_performance_status: Option<ProcessingPerformanceStatusDto>,
3782    pub read: Option<String>,
3783    #[serde(rename = "runStatus")]
3784    pub run_status: Option<String>,
3785    #[serde(rename = "taskCount")]
3786    pub task_count: Option<i32>,
3787    pub tasks: Option<String>,
3788    #[serde(rename = "tasksDuration")]
3789    pub tasks_duration: Option<String>,
3790    #[serde(rename = "tasksDurationNanos")]
3791    pub tasks_duration_nanos: Option<i64>,
3792    #[serde(rename = "terminatedThreadCount")]
3793    pub terminated_thread_count: Option<i32>,
3794    pub r#type: Option<String>,
3795    pub written: Option<String>,
3796}
3797
3798#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3799#[serde(rename_all = "camelCase")]
3800pub struct ProcessorStatusSnapshotEntity {
3801    #[serde(rename = "canRead")]
3802    pub can_read: Option<bool>,
3803    pub id: Option<String>,
3804    #[serde(rename = "processorStatusSnapshot")]
3805    pub processor_status_snapshot: Option<ProcessorStatusSnapshotDto>,
3806}
3807
3808#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3809#[serde(rename_all = "camelCase")]
3810pub struct ProcessorTypesEntity {
3811    #[serde(rename = "processorTypes")]
3812    pub processor_types: Option<Vec<DocumentedTypeDto>>,
3813}
3814
3815#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3816#[serde(rename_all = "camelCase")]
3817pub struct ProcessorsEntity {
3818    pub processors: Option<Vec<ProcessorEntity>>,
3819}
3820
3821#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3822#[serde(rename_all = "camelCase")]
3823pub struct ProcessorsRunStatusDetailsEntity {
3824    #[serde(rename = "runStatusDetails")]
3825    pub run_status_details: Option<Vec<ProcessorRunStatusDetailsEntity>>,
3826}
3827
3828#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3829#[serde(rename_all = "camelCase")]
3830pub struct PropertyAllowableValue {
3831    pub description: Option<String>,
3832    #[serde(rename = "displayName")]
3833    pub display_name: Option<String>,
3834    pub value: Option<String>,
3835}
3836
3837#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3838#[serde(rename_all = "camelCase")]
3839pub struct PropertyDependency {
3840    #[serde(rename = "dependentValues")]
3841    pub dependent_values: Option<Vec<String>>,
3842    #[serde(rename = "propertyDisplayName")]
3843    pub property_display_name: Option<String>,
3844    #[serde(rename = "propertyName")]
3845    pub property_name: Option<String>,
3846}
3847
3848#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3849#[serde(rename_all = "camelCase")]
3850pub struct PropertyDependencyDto {
3851    #[serde(rename = "dependentValues")]
3852    pub dependent_values: Option<Vec<String>>,
3853    #[serde(rename = "propertyName")]
3854    pub property_name: Option<String>,
3855}
3856
3857#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3858#[serde(rename_all = "camelCase")]
3859pub struct PropertyDescriptor {
3860    #[serde(rename = "allowableValues")]
3861    pub allowable_values: Option<Vec<PropertyAllowableValue>>,
3862    #[serde(rename = "defaultValue")]
3863    pub default_value: Option<String>,
3864    pub dependencies: Option<Vec<PropertyDependency>>,
3865    pub description: Option<String>,
3866    #[serde(rename = "displayName")]
3867    pub display_name: Option<String>,
3868    pub dynamic: Option<bool>,
3869    #[serde(rename = "expressionLanguageScope")]
3870    pub expression_language_scope: Option<String>,
3871    #[serde(rename = "expressionLanguageScopeDescription")]
3872    pub expression_language_scope_description: Option<String>,
3873    #[serde(rename = "listenPortDefinition")]
3874    pub listen_port_definition: Option<PropertyListenPortDefinition>,
3875    pub name: Option<String>,
3876    pub required: Option<bool>,
3877    #[serde(rename = "resourceDefinition")]
3878    pub resource_definition: Option<PropertyResourceDefinition>,
3879    pub sensitive: Option<bool>,
3880    #[serde(rename = "typeProvidedByValue")]
3881    pub type_provided_by_value: Option<DefinedType>,
3882    #[serde(rename = "validRegex")]
3883    pub valid_regex: Option<String>,
3884    pub validator: Option<String>,
3885}
3886
3887#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3888#[serde(rename_all = "camelCase")]
3889pub struct PropertyDescriptorDto {
3890    #[serde(rename = "allowableValues")]
3891    pub allowable_values: Option<Vec<AllowableValueEntity>>,
3892    #[serde(rename = "defaultValue")]
3893    pub default_value: Option<String>,
3894    pub dependencies: Option<Vec<PropertyDependencyDto>>,
3895    pub description: Option<String>,
3896    #[serde(rename = "displayName")]
3897    pub display_name: Option<String>,
3898    pub dynamic: Option<bool>,
3899    #[serde(rename = "expressionLanguageScope")]
3900    pub expression_language_scope: Option<String>,
3901    #[serde(rename = "identifiesControllerService")]
3902    pub identifies_controller_service: Option<String>,
3903    #[serde(rename = "identifiesControllerServiceBundle")]
3904    pub identifies_controller_service_bundle: Option<BundleDto>,
3905    pub name: Option<String>,
3906    pub required: Option<bool>,
3907    pub sensitive: Option<bool>,
3908    #[serde(rename = "supportsEl")]
3909    pub supports_el: Option<bool>,
3910}
3911
3912#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3913#[serde(rename_all = "camelCase")]
3914pub(crate) struct PropertyDescriptorEntity {
3915    pub property_descriptor: Option<PropertyDescriptorDto>,
3916}
3917
3918#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3919#[serde(rename_all = "camelCase")]
3920pub struct PropertyHistoryDto {
3921    #[serde(rename = "previousValues")]
3922    pub previous_values: Option<Vec<PreviousValueDto>>,
3923}
3924
3925#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3926#[serde(rename_all = "camelCase")]
3927pub struct PropertyListenPortDefinition {
3928    #[serde(rename = "applicationProtocols")]
3929    pub application_protocols: Option<Vec<String>>,
3930    #[serde(rename = "transportProtocol")]
3931    pub transport_protocol: Option<String>,
3932}
3933
3934#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3935#[serde(rename_all = "camelCase")]
3936pub struct PropertyResourceDefinition {
3937    pub cardinality: Option<String>,
3938    #[serde(rename = "resourceTypes")]
3939    pub resource_types: Option<Vec<String>>,
3940}
3941
3942#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3943#[serde(rename_all = "camelCase")]
3944pub struct ProvenanceDto {
3945    pub expiration: Option<String>,
3946    pub finished: Option<bool>,
3947    pub id: Option<String>,
3948    #[serde(rename = "percentCompleted")]
3949    pub percent_completed: Option<i32>,
3950    pub request: Option<ProvenanceRequestDto>,
3951    pub results: Option<ProvenanceResultsDto>,
3952    #[serde(rename = "submissionTime")]
3953    pub submission_time: Option<String>,
3954    pub uri: Option<String>,
3955}
3956
3957#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3958#[serde(rename_all = "camelCase")]
3959pub(crate) struct ProvenanceEntity {
3960    pub provenance: Option<ProvenanceDto>,
3961}
3962
3963#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3964#[serde(rename_all = "camelCase")]
3965pub struct ProvenanceEventDto {
3966    #[serde(rename = "alternateIdentifierUri")]
3967    pub alternate_identifier_uri: Option<String>,
3968    pub attributes: Option<Vec<AttributeDto>>,
3969    #[serde(rename = "childUuids")]
3970    pub child_uuids: Option<Vec<String>>,
3971    #[serde(rename = "clusterNodeAddress")]
3972    pub cluster_node_address: Option<String>,
3973    #[serde(rename = "clusterNodeId")]
3974    pub cluster_node_id: Option<String>,
3975    #[serde(rename = "componentId")]
3976    pub component_id: Option<String>,
3977    #[serde(rename = "componentName")]
3978    pub component_name: Option<String>,
3979    #[serde(rename = "componentType")]
3980    pub component_type: Option<String>,
3981    #[serde(rename = "contentEqual")]
3982    pub content_equal: Option<bool>,
3983    pub details: Option<String>,
3984    #[serde(rename = "eventDuration")]
3985    pub event_duration: Option<i64>,
3986    #[serde(rename = "eventId")]
3987    pub event_id: Option<i64>,
3988    #[serde(rename = "eventTime")]
3989    pub event_time: Option<String>,
3990    #[serde(rename = "eventTimestamp")]
3991    pub event_timestamp: Option<String>,
3992    #[serde(rename = "eventType")]
3993    pub event_type: Option<String>,
3994    #[serde(rename = "fileSize")]
3995    pub file_size: Option<String>,
3996    #[serde(rename = "fileSizeBytes")]
3997    pub file_size_bytes: Option<i64>,
3998    #[serde(rename = "flowFileUuid")]
3999    pub flow_file_uuid: Option<String>,
4000    #[serde(rename = "groupId")]
4001    pub group_id: Option<String>,
4002    pub id: Option<String>,
4003    #[serde(rename = "inputContentAvailable")]
4004    pub input_content_available: Option<bool>,
4005    #[serde(rename = "inputContentClaimContainer")]
4006    pub input_content_claim_container: Option<String>,
4007    #[serde(rename = "inputContentClaimFileSize")]
4008    pub input_content_claim_file_size: Option<String>,
4009    #[serde(rename = "inputContentClaimFileSizeBytes")]
4010    pub input_content_claim_file_size_bytes: Option<i64>,
4011    #[serde(rename = "inputContentClaimIdentifier")]
4012    pub input_content_claim_identifier: Option<String>,
4013    #[serde(rename = "inputContentClaimOffset")]
4014    pub input_content_claim_offset: Option<i64>,
4015    #[serde(rename = "inputContentClaimSection")]
4016    pub input_content_claim_section: Option<String>,
4017    #[serde(rename = "lineageDuration")]
4018    pub lineage_duration: Option<i64>,
4019    #[serde(rename = "outputContentAvailable")]
4020    pub output_content_available: Option<bool>,
4021    #[serde(rename = "outputContentClaimContainer")]
4022    pub output_content_claim_container: Option<String>,
4023    #[serde(rename = "outputContentClaimFileSize")]
4024    pub output_content_claim_file_size: Option<String>,
4025    #[serde(rename = "outputContentClaimFileSizeBytes")]
4026    pub output_content_claim_file_size_bytes: Option<i64>,
4027    #[serde(rename = "outputContentClaimIdentifier")]
4028    pub output_content_claim_identifier: Option<String>,
4029    #[serde(rename = "outputContentClaimOffset")]
4030    pub output_content_claim_offset: Option<i64>,
4031    #[serde(rename = "outputContentClaimSection")]
4032    pub output_content_claim_section: Option<String>,
4033    #[serde(rename = "parentUuids")]
4034    pub parent_uuids: Option<Vec<String>>,
4035    pub relationship: Option<String>,
4036    #[serde(rename = "replayAvailable")]
4037    pub replay_available: Option<bool>,
4038    #[serde(rename = "replayExplanation")]
4039    pub replay_explanation: Option<String>,
4040    #[serde(rename = "sourceConnectionIdentifier")]
4041    pub source_connection_identifier: Option<String>,
4042    #[serde(rename = "sourceSystemFlowFileId")]
4043    pub source_system_flow_file_id: Option<String>,
4044    #[serde(rename = "transitUri")]
4045    pub transit_uri: Option<String>,
4046}
4047
4048#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4049#[serde(rename_all = "camelCase")]
4050pub(crate) struct ProvenanceEventEntity {
4051    pub provenance_event: Option<ProvenanceEventDto>,
4052}
4053
4054#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4055#[serde(rename_all = "camelCase")]
4056pub struct ProvenanceLinkDto {
4057    #[serde(rename = "flowFileUuid")]
4058    pub flow_file_uuid: Option<String>,
4059    pub millis: Option<i64>,
4060    #[serde(rename = "sourceId")]
4061    pub source_id: Option<String>,
4062    #[serde(rename = "targetId")]
4063    pub target_id: Option<String>,
4064    pub timestamp: Option<String>,
4065}
4066
4067#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4068#[serde(rename_all = "camelCase")]
4069pub struct ProvenanceNodeDto {
4070    #[serde(rename = "childUuids")]
4071    pub child_uuids: Option<Vec<String>>,
4072    #[serde(rename = "clusterNodeIdentifier")]
4073    pub cluster_node_identifier: Option<String>,
4074    #[serde(rename = "componentType")]
4075    pub component_type: Option<String>,
4076    #[serde(rename = "eventType")]
4077    pub event_type: Option<String>,
4078    #[serde(rename = "flowFileUuid")]
4079    pub flow_file_uuid: Option<String>,
4080    pub id: Option<String>,
4081    pub millis: Option<i64>,
4082    #[serde(rename = "parentUuids")]
4083    pub parent_uuids: Option<Vec<String>>,
4084    pub timestamp: Option<String>,
4085    pub r#type: Option<String>,
4086}
4087
4088#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4089#[serde(rename_all = "camelCase")]
4090pub struct ProvenanceOptionsDto {
4091    #[serde(rename = "searchableFields")]
4092    pub searchable_fields: Option<Vec<ProvenanceSearchableFieldDto>>,
4093}
4094
4095#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4096#[serde(rename_all = "camelCase")]
4097pub(crate) struct ProvenanceOptionsEntity {
4098    pub provenance_options: Option<ProvenanceOptionsDto>,
4099}
4100
4101#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4102#[serde(rename_all = "camelCase")]
4103pub struct ProvenanceRequestDto {
4104    #[serde(rename = "clusterNodeId")]
4105    pub cluster_node_id: Option<String>,
4106    #[serde(rename = "endDate")]
4107    pub end_date: Option<String>,
4108    #[serde(rename = "incrementalResults")]
4109    pub incremental_results: Option<bool>,
4110    #[serde(rename = "maxResults")]
4111    pub max_results: Option<i32>,
4112    #[serde(rename = "maximumFileSize")]
4113    pub maximum_file_size: Option<String>,
4114    #[serde(rename = "minimumFileSize")]
4115    pub minimum_file_size: Option<String>,
4116    #[serde(rename = "searchTerms")]
4117    pub search_terms: Option<std::collections::HashMap<String, Option<ProvenanceSearchValueDto>>>,
4118    #[serde(rename = "startDate")]
4119    pub start_date: Option<String>,
4120    pub summarize: Option<bool>,
4121}
4122
4123#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4124#[serde(rename_all = "camelCase")]
4125pub struct ProvenanceResultsDto {
4126    pub errors: Option<Vec<String>>,
4127    pub generated: Option<String>,
4128    #[serde(rename = "oldestEvent")]
4129    pub oldest_event: Option<String>,
4130    #[serde(rename = "provenanceEvents")]
4131    pub provenance_events: Option<Vec<ProvenanceEventDto>>,
4132    #[serde(rename = "timeOffset")]
4133    pub time_offset: Option<i32>,
4134    pub total: Option<String>,
4135    #[serde(rename = "totalCount")]
4136    pub total_count: Option<i64>,
4137}
4138
4139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4140#[serde(rename_all = "camelCase")]
4141pub struct ProvenanceSearchValueDto {
4142    pub inverse: Option<bool>,
4143    pub value: Option<String>,
4144}
4145
4146#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4147#[serde(rename_all = "camelCase")]
4148pub struct ProvenanceSearchableFieldDto {
4149    pub field: Option<String>,
4150    pub id: Option<String>,
4151    pub label: Option<String>,
4152    pub r#type: Option<String>,
4153}
4154
4155#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4156#[serde(rename_all = "camelCase")]
4157pub struct QueueSizeDto {
4158    #[serde(rename = "byteCount")]
4159    pub byte_count: Option<i64>,
4160    #[serde(rename = "objectCount")]
4161    pub object_count: Option<i32>,
4162}
4163
4164#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4165#[serde(rename_all = "camelCase")]
4166pub struct RegisteredFlow {
4167    pub branch: Option<String>,
4168    #[serde(rename = "bucketIdentifier")]
4169    pub bucket_identifier: Option<String>,
4170    #[serde(rename = "bucketName")]
4171    pub bucket_name: Option<String>,
4172    #[serde(rename = "createdTimestamp")]
4173    pub created_timestamp: Option<i64>,
4174    pub description: Option<String>,
4175    pub identifier: Option<String>,
4176    #[serde(rename = "lastModifiedTimestamp")]
4177    pub last_modified_timestamp: Option<i64>,
4178    pub name: Option<String>,
4179    pub permissions: Option<FlowRegistryPermissions>,
4180    #[serde(rename = "versionCount")]
4181    pub version_count: Option<i64>,
4182    #[serde(rename = "versionInfo")]
4183    pub version_info: Option<RegisteredFlowVersionInfo>,
4184}
4185
4186#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4187#[serde(rename_all = "camelCase")]
4188pub struct RegisteredFlowSnapshot {
4189    pub bucket: Option<FlowRegistryBucket>,
4190    #[serde(rename = "externalControllerServices")]
4191    pub external_controller_services:
4192        Option<std::collections::HashMap<String, Option<ExternalControllerServiceReference>>>,
4193    pub flow: Option<RegisteredFlow>,
4194    #[serde(rename = "flowContents")]
4195    pub flow_contents: Option<VersionedProcessGroup>,
4196    #[serde(rename = "flowEncodingVersion")]
4197    pub flow_encoding_version: Option<String>,
4198    pub latest: Option<bool>,
4199    #[serde(rename = "parameterContexts")]
4200    pub parameter_contexts:
4201        Option<std::collections::HashMap<String, Option<VersionedParameterContext>>>,
4202    #[serde(rename = "parameterProviders")]
4203    pub parameter_providers:
4204        Option<std::collections::HashMap<String, Option<ParameterProviderReference>>>,
4205    #[serde(rename = "snapshotMetadata")]
4206    pub snapshot_metadata: Option<RegisteredFlowSnapshotMetadata>,
4207}
4208
4209#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4210#[serde(rename_all = "camelCase")]
4211pub struct RegisteredFlowSnapshotMetadata {
4212    pub author: Option<String>,
4213    pub branch: Option<String>,
4214    #[serde(rename = "bucketIdentifier")]
4215    pub bucket_identifier: Option<String>,
4216    pub comments: Option<String>,
4217    #[serde(rename = "flowIdentifier")]
4218    pub flow_identifier: Option<String>,
4219    #[serde(rename = "flowName")]
4220    pub flow_name: Option<String>,
4221    #[serde(rename = "registryIdentifier")]
4222    pub registry_identifier: Option<String>,
4223    #[serde(rename = "registryName")]
4224    pub registry_name: Option<String>,
4225    pub timestamp: Option<i64>,
4226    pub version: Option<String>,
4227}
4228
4229#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4230#[serde(rename_all = "camelCase")]
4231pub struct RegisteredFlowVersionInfo {
4232    pub version: Option<i64>,
4233}
4234
4235#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4236#[serde(rename_all = "camelCase")]
4237pub struct Relationship {
4238    pub description: Option<String>,
4239    pub name: Option<String>,
4240}
4241
4242#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4243#[serde(rename_all = "camelCase")]
4244pub struct RelationshipDto {
4245    #[serde(rename = "autoTerminate")]
4246    pub auto_terminate: Option<bool>,
4247    pub description: Option<String>,
4248    pub name: Option<String>,
4249    pub retry: Option<bool>,
4250}
4251
4252#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4253#[serde(rename_all = "camelCase")]
4254pub struct RemotePortRunStatusEntity {
4255    #[serde(rename = "disconnectedNodeAcknowledged")]
4256    pub disconnected_node_acknowledged: Option<bool>,
4257    pub revision: Option<RevisionDto>,
4258    pub state: Option<String>,
4259}
4260
4261#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4262#[serde(rename_all = "camelCase")]
4263pub struct RemoteProcessGroupContentsDto {
4264    #[serde(rename = "inputPorts")]
4265    pub input_ports: Option<Vec<RemoteProcessGroupPortDto>>,
4266    #[serde(rename = "outputPorts")]
4267    pub output_ports: Option<Vec<RemoteProcessGroupPortDto>>,
4268}
4269
4270#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4271#[serde(rename_all = "camelCase")]
4272pub struct RemoteProcessGroupDto {
4273    #[serde(rename = "activeRemoteInputPortCount")]
4274    pub active_remote_input_port_count: Option<i32>,
4275    #[serde(rename = "activeRemoteOutputPortCount")]
4276    pub active_remote_output_port_count: Option<i32>,
4277    #[serde(rename = "authorizationIssues")]
4278    pub authorization_issues: Option<Vec<String>>,
4279    pub comments: Option<String>,
4280    #[serde(rename = "communicationsTimeout")]
4281    pub communications_timeout: Option<String>,
4282    pub contents: Option<RemoteProcessGroupContentsDto>,
4283    #[serde(rename = "flowRefreshed")]
4284    pub flow_refreshed: Option<String>,
4285    pub id: Option<String>,
4286    #[serde(rename = "inactiveRemoteInputPortCount")]
4287    pub inactive_remote_input_port_count: Option<i32>,
4288    #[serde(rename = "inactiveRemoteOutputPortCount")]
4289    pub inactive_remote_output_port_count: Option<i32>,
4290    #[serde(rename = "inputPortCount")]
4291    pub input_port_count: Option<i32>,
4292    #[serde(rename = "localNetworkInterface")]
4293    pub local_network_interface: Option<String>,
4294    pub name: Option<String>,
4295    #[serde(rename = "outputPortCount")]
4296    pub output_port_count: Option<i32>,
4297    #[serde(rename = "parentGroupId")]
4298    pub parent_group_id: Option<String>,
4299    pub position: Option<PositionDto>,
4300    #[serde(rename = "proxyHost")]
4301    pub proxy_host: Option<String>,
4302    #[serde(rename = "proxyPassword")]
4303    pub proxy_password: Option<String>,
4304    #[serde(rename = "proxyPort")]
4305    pub proxy_port: Option<i32>,
4306    #[serde(rename = "proxyUser")]
4307    pub proxy_user: Option<String>,
4308    #[serde(rename = "targetSecure")]
4309    pub target_secure: Option<bool>,
4310    #[serde(rename = "targetUri")]
4311    pub target_uri: Option<String>,
4312    #[serde(rename = "targetUris")]
4313    pub target_uris: Option<String>,
4314    pub transmitting: Option<bool>,
4315    #[serde(rename = "transportProtocol")]
4316    pub transport_protocol: Option<String>,
4317    #[serde(rename = "validationErrors")]
4318    pub validation_errors: Option<Vec<String>>,
4319    #[serde(rename = "versionedComponentId")]
4320    pub versioned_component_id: Option<String>,
4321    #[serde(rename = "yieldDuration")]
4322    pub yield_duration: Option<String>,
4323}
4324
4325#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4326#[serde(rename_all = "camelCase")]
4327pub struct RemoteProcessGroupEntity {
4328    pub bulletins: Option<Vec<BulletinEntity>>,
4329    pub component: Option<RemoteProcessGroupDto>,
4330    #[serde(rename = "disconnectedNodeAcknowledged")]
4331    pub disconnected_node_acknowledged: Option<bool>,
4332    pub id: Option<String>,
4333    #[serde(rename = "inputPortCount")]
4334    pub input_port_count: Option<i32>,
4335    #[serde(rename = "operatePermissions")]
4336    pub operate_permissions: Option<PermissionsDto>,
4337    #[serde(rename = "outputPortCount")]
4338    pub output_port_count: Option<i32>,
4339    pub permissions: Option<PermissionsDto>,
4340    pub position: Option<PositionDto>,
4341    pub revision: Option<RevisionDto>,
4342    pub status: Option<RemoteProcessGroupStatusDto>,
4343    pub uri: Option<String>,
4344}
4345
4346#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4347#[serde(rename_all = "camelCase")]
4348pub struct RemoteProcessGroupPortDto {
4349    #[serde(rename = "batchSettings")]
4350    pub batch_settings: Option<BatchSettingsDto>,
4351    pub comments: Option<String>,
4352    #[serde(rename = "concurrentlySchedulableTaskCount")]
4353    pub concurrently_schedulable_task_count: Option<i32>,
4354    pub connected: Option<bool>,
4355    pub exists: Option<bool>,
4356    #[serde(rename = "groupId")]
4357    pub group_id: Option<String>,
4358    pub id: Option<String>,
4359    pub name: Option<String>,
4360    #[serde(rename = "targetId")]
4361    pub target_id: Option<String>,
4362    #[serde(rename = "targetRunning")]
4363    pub target_running: Option<bool>,
4364    pub transmitting: Option<bool>,
4365    #[serde(rename = "useCompression")]
4366    pub use_compression: Option<bool>,
4367    #[serde(rename = "versionedComponentId")]
4368    pub versioned_component_id: Option<String>,
4369}
4370
4371#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4372#[serde(rename_all = "camelCase")]
4373pub struct RemoteProcessGroupPortEntity {
4374    pub bulletins: Option<Vec<BulletinEntity>>,
4375    #[serde(rename = "disconnectedNodeAcknowledged")]
4376    pub disconnected_node_acknowledged: Option<bool>,
4377    pub id: Option<String>,
4378    #[serde(rename = "operatePermissions")]
4379    pub operate_permissions: Option<PermissionsDto>,
4380    pub permissions: Option<PermissionsDto>,
4381    pub position: Option<PositionDto>,
4382    #[serde(rename = "remoteProcessGroupPort")]
4383    pub remote_process_group_port: Option<RemoteProcessGroupPortDto>,
4384    pub revision: Option<RevisionDto>,
4385    pub uri: Option<String>,
4386}
4387
4388#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4389#[serde(rename_all = "camelCase")]
4390pub struct RemoteProcessGroupStatusDto {
4391    #[serde(rename = "aggregateSnapshot")]
4392    pub aggregate_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
4393    #[serde(rename = "groupId")]
4394    pub group_id: Option<String>,
4395    pub id: Option<String>,
4396    pub name: Option<String>,
4397    #[serde(rename = "nodeSnapshots")]
4398    pub node_snapshots: Option<Vec<NodeRemoteProcessGroupStatusSnapshotDto>>,
4399    #[serde(rename = "statsLastRefreshed")]
4400    pub stats_last_refreshed: Option<String>,
4401    #[serde(rename = "targetUri")]
4402    pub target_uri: Option<String>,
4403    #[serde(rename = "transmissionStatus")]
4404    pub transmission_status: Option<String>,
4405    #[serde(rename = "validationStatus")]
4406    pub validation_status: Option<String>,
4407}
4408
4409#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4410#[serde(rename_all = "camelCase")]
4411pub struct RemoteProcessGroupStatusEntity {
4412    #[serde(rename = "canRead")]
4413    pub can_read: Option<bool>,
4414    #[serde(rename = "remoteProcessGroupStatus")]
4415    pub remote_process_group_status: Option<RemoteProcessGroupStatusDto>,
4416}
4417
4418#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4419#[serde(rename_all = "camelCase")]
4420pub struct RemoteProcessGroupStatusSnapshotDto {
4421    #[serde(rename = "activeThreadCount")]
4422    pub active_thread_count: Option<i32>,
4423    #[serde(rename = "bytesReceived")]
4424    pub bytes_received: Option<i64>,
4425    #[serde(rename = "bytesSent")]
4426    pub bytes_sent: Option<i64>,
4427    #[serde(rename = "flowFilesReceived")]
4428    pub flow_files_received: Option<i32>,
4429    #[serde(rename = "flowFilesSent")]
4430    pub flow_files_sent: Option<i32>,
4431    #[serde(rename = "groupId")]
4432    pub group_id: Option<String>,
4433    pub id: Option<String>,
4434    pub name: Option<String>,
4435    pub received: Option<String>,
4436    pub sent: Option<String>,
4437    #[serde(rename = "targetUri")]
4438    pub target_uri: Option<String>,
4439    #[serde(rename = "transmissionStatus")]
4440    pub transmission_status: Option<String>,
4441}
4442
4443#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4444#[serde(rename_all = "camelCase")]
4445pub struct RemoteProcessGroupStatusSnapshotEntity {
4446    #[serde(rename = "canRead")]
4447    pub can_read: Option<bool>,
4448    pub id: Option<String>,
4449    #[serde(rename = "remoteProcessGroupStatusSnapshot")]
4450    pub remote_process_group_status_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
4451}
4452
4453#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4454#[serde(rename_all = "camelCase")]
4455pub struct RemoteProcessGroupsEntity {
4456    #[serde(rename = "remoteProcessGroups")]
4457    pub remote_process_groups: Option<Vec<RemoteProcessGroupEntity>>,
4458}
4459
4460#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4461#[serde(rename_all = "camelCase")]
4462pub struct ReplayLastEventRequestEntity {
4463    #[serde(rename = "componentId")]
4464    pub component_id: Option<String>,
4465    pub nodes: Option<String>,
4466}
4467
4468#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4469#[serde(rename_all = "camelCase")]
4470pub struct ReplayLastEventResponseEntity {
4471    #[serde(rename = "aggregateSnapshot")]
4472    pub aggregate_snapshot: Option<ReplayLastEventSnapshotDto>,
4473    #[serde(rename = "componentId")]
4474    pub component_id: Option<String>,
4475    #[serde(rename = "nodeSnapshots")]
4476    pub node_snapshots: Option<Vec<NodeReplayLastEventSnapshotDto>>,
4477    pub nodes: Option<String>,
4478}
4479
4480#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4481#[serde(rename_all = "camelCase")]
4482pub struct ReplayLastEventSnapshotDto {
4483    #[serde(rename = "eventAvailable")]
4484    pub event_available: Option<bool>,
4485    #[serde(rename = "eventsReplayed")]
4486    pub events_replayed: Option<Vec<i64>>,
4487    #[serde(rename = "failureExplanation")]
4488    pub failure_explanation: Option<String>,
4489}
4490
4491#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4492#[serde(rename_all = "camelCase")]
4493pub struct ReportingTaskDefinition {
4494    #[serde(rename = "additionalDetails")]
4495    pub additional_details: Option<bool>,
4496    pub artifact: Option<String>,
4497    #[serde(rename = "buildInfo")]
4498    pub build_info: Option<BuildInfo>,
4499    #[serde(rename = "defaultSchedulingPeriodBySchedulingStrategy")]
4500    pub default_scheduling_period_by_scheduling_strategy:
4501        Option<std::collections::HashMap<String, Option<String>>>,
4502    #[serde(rename = "defaultSchedulingStrategy")]
4503    pub default_scheduling_strategy: Option<String>,
4504    pub deprecated: Option<bool>,
4505    #[serde(rename = "deprecationAlternatives")]
4506    pub deprecation_alternatives: Option<Vec<String>>,
4507    #[serde(rename = "deprecationReason")]
4508    pub deprecation_reason: Option<String>,
4509    #[serde(rename = "dynamicProperties")]
4510    pub dynamic_properties: Option<Vec<DynamicProperty>>,
4511    #[serde(rename = "explicitRestrictions")]
4512    pub explicit_restrictions: Option<Vec<Restriction>>,
4513    pub group: Option<String>,
4514    #[serde(rename = "propertyDescriptors")]
4515    pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
4516    #[serde(rename = "providedApiImplementations")]
4517    pub provided_api_implementations: Option<Vec<DefinedType>>,
4518    pub restricted: Option<bool>,
4519    #[serde(rename = "restrictedExplanation")]
4520    pub restricted_explanation: Option<String>,
4521    #[serde(rename = "seeAlso")]
4522    pub see_also: Option<Vec<String>>,
4523    pub stateful: Option<Stateful>,
4524    #[serde(rename = "supportedSchedulingStrategies")]
4525    pub supported_scheduling_strategies: Option<Vec<String>>,
4526    #[serde(rename = "supportsDynamicProperties")]
4527    pub supports_dynamic_properties: Option<bool>,
4528    #[serde(rename = "supportsSensitiveDynamicProperties")]
4529    pub supports_sensitive_dynamic_properties: Option<bool>,
4530    #[serde(rename = "systemResourceConsiderations")]
4531    pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
4532    pub tags: Option<Vec<String>>,
4533    pub r#type: Option<String>,
4534    #[serde(rename = "typeDescription")]
4535    pub type_description: Option<String>,
4536    pub version: Option<String>,
4537}
4538
4539#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4540#[serde(rename_all = "camelCase")]
4541pub struct ReportingTaskDto {
4542    #[serde(rename = "activeThreadCount")]
4543    pub active_thread_count: Option<i32>,
4544    #[serde(rename = "annotationData")]
4545    pub annotation_data: Option<String>,
4546    pub bundle: Option<BundleDto>,
4547    pub comments: Option<String>,
4548    #[serde(rename = "customUiUrl")]
4549    pub custom_ui_url: Option<String>,
4550    #[serde(rename = "defaultSchedulingPeriod")]
4551    pub default_scheduling_period: Option<std::collections::HashMap<String, Option<String>>>,
4552    pub deprecated: Option<bool>,
4553    pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
4554    #[serde(rename = "extensionMissing")]
4555    pub extension_missing: Option<bool>,
4556    pub id: Option<String>,
4557    #[serde(rename = "multipleVersionsAvailable")]
4558    pub multiple_versions_available: Option<bool>,
4559    pub name: Option<String>,
4560    #[serde(rename = "parentGroupId")]
4561    pub parent_group_id: Option<String>,
4562    #[serde(rename = "persistsState")]
4563    pub persists_state: Option<bool>,
4564    pub position: Option<PositionDto>,
4565    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
4566    pub restricted: Option<bool>,
4567    #[serde(rename = "schedulingPeriod")]
4568    pub scheduling_period: Option<String>,
4569    #[serde(rename = "schedulingStrategy")]
4570    pub scheduling_strategy: Option<String>,
4571    #[serde(rename = "sensitiveDynamicPropertyNames")]
4572    pub sensitive_dynamic_property_names: Option<Vec<String>>,
4573    pub state: Option<String>,
4574    #[serde(rename = "supportsSensitiveDynamicProperties")]
4575    pub supports_sensitive_dynamic_properties: Option<bool>,
4576    pub r#type: Option<String>,
4577    #[serde(rename = "validationErrors")]
4578    pub validation_errors: Option<Vec<String>>,
4579    #[serde(rename = "validationStatus")]
4580    pub validation_status: Option<String>,
4581    #[serde(rename = "versionedComponentId")]
4582    pub versioned_component_id: Option<String>,
4583}
4584
4585#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4586#[serde(rename_all = "camelCase")]
4587pub struct ReportingTaskEntity {
4588    pub bulletins: Option<Vec<BulletinEntity>>,
4589    pub component: Option<ReportingTaskDto>,
4590    #[serde(rename = "disconnectedNodeAcknowledged")]
4591    pub disconnected_node_acknowledged: Option<bool>,
4592    pub id: Option<String>,
4593    #[serde(rename = "operatePermissions")]
4594    pub operate_permissions: Option<PermissionsDto>,
4595    pub permissions: Option<PermissionsDto>,
4596    pub position: Option<PositionDto>,
4597    pub revision: Option<RevisionDto>,
4598    pub status: Option<ReportingTaskStatusDto>,
4599    pub uri: Option<String>,
4600}
4601
4602#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4603#[serde(rename_all = "camelCase")]
4604pub struct ReportingTaskRunStatusEntity {
4605    #[serde(rename = "disconnectedNodeAcknowledged")]
4606    pub disconnected_node_acknowledged: Option<bool>,
4607    pub revision: Option<RevisionDto>,
4608    pub state: Option<String>,
4609}
4610
4611#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4612#[serde(rename_all = "camelCase")]
4613pub struct ReportingTaskStatusDto {
4614    #[serde(rename = "activeThreadCount")]
4615    pub active_thread_count: Option<i32>,
4616    #[serde(rename = "runStatus")]
4617    pub run_status: Option<String>,
4618    #[serde(rename = "validationStatus")]
4619    pub validation_status: Option<String>,
4620}
4621
4622#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4623#[serde(rename_all = "camelCase")]
4624pub struct ReportingTaskTypesEntity {
4625    #[serde(rename = "reportingTaskTypes")]
4626    pub reporting_task_types: Option<Vec<DocumentedTypeDto>>,
4627}
4628
4629#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4630#[serde(rename_all = "camelCase")]
4631pub struct ReportingTasksEntity {
4632    #[serde(rename = "currentTime")]
4633    pub current_time: Option<String>,
4634    #[serde(rename = "reportingTasks")]
4635    pub reporting_tasks: Option<Vec<ReportingTaskEntity>>,
4636}
4637
4638#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4639#[serde(rename_all = "camelCase")]
4640pub struct RequiredPermissionDto {
4641    pub id: Option<String>,
4642    pub label: Option<String>,
4643}
4644
4645#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4646#[serde(rename_all = "camelCase")]
4647pub struct ResourceClaimDetailsDto {
4648    #[serde(rename = "awaitingDestruction")]
4649    pub awaiting_destruction: Option<bool>,
4650    #[serde(rename = "claimantCount")]
4651    pub claimant_count: Option<i32>,
4652    pub container: Option<String>,
4653    pub identifier: Option<String>,
4654    #[serde(rename = "inUse")]
4655    pub in_use: Option<bool>,
4656    pub section: Option<String>,
4657    pub writable: Option<bool>,
4658}
4659
4660#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4661#[serde(rename_all = "camelCase")]
4662pub struct ResourceDto {
4663    pub identifier: Option<String>,
4664    pub name: Option<String>,
4665}
4666
4667#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4668#[serde(rename_all = "camelCase")]
4669pub struct ResourcesEntity {
4670    pub resources: Option<Vec<ResourceDto>>,
4671}
4672
4673#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4674#[serde(rename_all = "camelCase")]
4675pub struct Restriction {
4676    pub explanation: Option<String>,
4677    #[serde(rename = "requiredPermission")]
4678    pub required_permission: Option<String>,
4679}
4680
4681#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4682#[serde(rename_all = "camelCase")]
4683pub struct RevisionDto {
4684    #[serde(rename = "clientId")]
4685    pub client_id: Option<String>,
4686    #[serde(rename = "lastModifier")]
4687    pub last_modifier: Option<String>,
4688    pub version: Option<i64>,
4689}
4690
4691#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4692#[serde(rename_all = "camelCase")]
4693pub struct RunStatusDetailsRequestEntity {
4694    #[serde(rename = "processorIds")]
4695    pub processor_ids: Option<Vec<String>>,
4696}
4697
4698#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4699#[serde(rename_all = "camelCase")]
4700pub struct RuntimeManifest {
4701    #[serde(rename = "agentType")]
4702    pub agent_type: Option<String>,
4703    #[serde(rename = "buildInfo")]
4704    pub build_info: Option<BuildInfo>,
4705    pub bundles: Option<Vec<Bundle>>,
4706    pub identifier: Option<String>,
4707    #[serde(rename = "schedulingDefaults")]
4708    pub scheduling_defaults: Option<SchedulingDefaults>,
4709    pub version: Option<String>,
4710}
4711
4712#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4713#[serde(rename_all = "camelCase")]
4714pub(crate) struct RuntimeManifestEntity {
4715    pub runtime_manifest: Option<RuntimeManifest>,
4716}
4717
4718#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4719#[serde(rename_all = "camelCase")]
4720pub struct ScheduleComponentsEntity {
4721    pub components: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4722    #[serde(rename = "disconnectedNodeAcknowledged")]
4723    pub disconnected_node_acknowledged: Option<bool>,
4724    pub id: Option<String>,
4725    pub state: Option<String>,
4726}
4727
4728#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4729#[serde(rename_all = "camelCase")]
4730pub struct SchedulingDefaults {
4731    #[serde(rename = "defaultConcurrentTasksBySchedulingStrategy")]
4732    pub default_concurrent_tasks_by_scheduling_strategy:
4733        Option<std::collections::HashMap<String, Option<i32>>>,
4734    #[serde(rename = "defaultMaxConcurrentTasks")]
4735    pub default_max_concurrent_tasks: Option<String>,
4736    #[serde(rename = "defaultRunDurationNanos")]
4737    pub default_run_duration_nanos: Option<i64>,
4738    #[serde(rename = "defaultSchedulingPeriodMillis")]
4739    pub default_scheduling_period_millis: Option<i64>,
4740    #[serde(rename = "defaultSchedulingPeriodsBySchedulingStrategy")]
4741    pub default_scheduling_periods_by_scheduling_strategy:
4742        Option<std::collections::HashMap<String, Option<String>>>,
4743    #[serde(rename = "defaultSchedulingStrategy")]
4744    pub default_scheduling_strategy: Option<String>,
4745    #[serde(rename = "penalizationPeriodMillis")]
4746    pub penalization_period_millis: Option<i64>,
4747    #[serde(rename = "yieldDurationMillis")]
4748    pub yield_duration_millis: Option<i64>,
4749}
4750
4751#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4752#[serde(rename_all = "camelCase")]
4753pub struct SearchResultGroupDto {
4754    pub id: Option<String>,
4755    pub name: Option<String>,
4756}
4757
4758#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4759#[serde(rename_all = "camelCase")]
4760pub struct SearchResultsDto {
4761    #[serde(rename = "connectionResults")]
4762    pub connection_results: Option<Vec<ComponentSearchResultDto>>,
4763    #[serde(rename = "controllerServiceNodeResults")]
4764    pub controller_service_node_results: Option<Vec<ComponentSearchResultDto>>,
4765    #[serde(rename = "funnelResults")]
4766    pub funnel_results: Option<Vec<ComponentSearchResultDto>>,
4767    #[serde(rename = "inputPortResults")]
4768    pub input_port_results: Option<Vec<ComponentSearchResultDto>>,
4769    #[serde(rename = "labelResults")]
4770    pub label_results: Option<Vec<ComponentSearchResultDto>>,
4771    #[serde(rename = "outputPortResults")]
4772    pub output_port_results: Option<Vec<ComponentSearchResultDto>>,
4773    #[serde(rename = "parameterContextResults")]
4774    pub parameter_context_results: Option<Vec<ComponentSearchResultDto>>,
4775    #[serde(rename = "parameterProviderNodeResults")]
4776    pub parameter_provider_node_results: Option<Vec<ComponentSearchResultDto>>,
4777    #[serde(rename = "parameterResults")]
4778    pub parameter_results: Option<Vec<ComponentSearchResultDto>>,
4779    #[serde(rename = "processGroupResults")]
4780    pub process_group_results: Option<Vec<ComponentSearchResultDto>>,
4781    #[serde(rename = "processorResults")]
4782    pub processor_results: Option<Vec<ComponentSearchResultDto>>,
4783    #[serde(rename = "remoteProcessGroupResults")]
4784    pub remote_process_group_results: Option<Vec<ComponentSearchResultDto>>,
4785}
4786
4787#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4788#[serde(rename_all = "camelCase")]
4789pub(crate) struct SearchResultsEntity {
4790    pub search_results_d_t_o: Option<SearchResultsDto>,
4791}
4792
4793#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4794#[serde(rename_all = "camelCase")]
4795pub struct SnippetDto {
4796    pub connections: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4797    pub funnels: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4798    pub id: Option<String>,
4799    #[serde(rename = "inputPorts")]
4800    pub input_ports: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4801    pub labels: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4802    #[serde(rename = "outputPorts")]
4803    pub output_ports: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4804    #[serde(rename = "parentGroupId")]
4805    pub parent_group_id: Option<String>,
4806    #[serde(rename = "processGroups")]
4807    pub process_groups: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4808    pub processors: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4809    #[serde(rename = "remoteProcessGroups")]
4810    pub remote_process_groups: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
4811    pub uri: Option<String>,
4812}
4813
4814#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4815#[serde(rename_all = "camelCase")]
4816pub struct SnippetEntity {
4817    #[serde(rename = "disconnectedNodeAcknowledged")]
4818    pub disconnected_node_acknowledged: Option<bool>,
4819    pub snippet: Option<SnippetDto>,
4820}
4821
4822#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4823#[serde(rename_all = "camelCase")]
4824pub struct StartVersionControlRequestEntity {
4825    #[serde(rename = "disconnectedNodeAcknowledged")]
4826    pub disconnected_node_acknowledged: Option<bool>,
4827    #[serde(rename = "processGroupRevision")]
4828    pub process_group_revision: Option<RevisionDto>,
4829    #[serde(rename = "versionedFlow")]
4830    pub versioned_flow: Option<VersionedFlowDto>,
4831}
4832
4833#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4834#[serde(rename_all = "camelCase")]
4835pub struct StateEntryDto {
4836    #[serde(rename = "clusterNodeAddress")]
4837    pub cluster_node_address: Option<String>,
4838    #[serde(rename = "clusterNodeId")]
4839    pub cluster_node_id: Option<String>,
4840    pub key: Option<String>,
4841    pub value: Option<String>,
4842}
4843
4844#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4845#[serde(rename_all = "camelCase")]
4846pub struct StateMapDto {
4847    pub scope: Option<String>,
4848    pub state: Option<Vec<StateEntryDto>>,
4849    #[serde(rename = "totalEntryCount")]
4850    pub total_entry_count: Option<i32>,
4851}
4852
4853#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4854#[serde(rename_all = "camelCase")]
4855pub struct Stateful {
4856    pub description: Option<String>,
4857    pub scopes: Option<Vec<String>>,
4858}
4859
4860#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4861#[serde(rename_all = "camelCase")]
4862pub struct StatusDescriptorDto {
4863    pub description: Option<String>,
4864    pub field: Option<String>,
4865    pub formatter: Option<String>,
4866    pub label: Option<String>,
4867}
4868
4869#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4870#[serde(rename_all = "camelCase")]
4871pub struct StatusHistoryDto {
4872    #[serde(rename = "aggregateSnapshots")]
4873    pub aggregate_snapshots: Option<Vec<StatusSnapshotDto>>,
4874    #[serde(rename = "componentDetails")]
4875    pub component_details: Option<std::collections::HashMap<String, Option<String>>>,
4876    #[serde(rename = "fieldDescriptors")]
4877    pub field_descriptors: Option<Vec<StatusDescriptorDto>>,
4878    pub generated: Option<String>,
4879    #[serde(rename = "nodeSnapshots")]
4880    pub node_snapshots: Option<Vec<NodeStatusSnapshotsDto>>,
4881}
4882
4883#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4884#[serde(rename_all = "camelCase")]
4885pub struct StatusHistoryEntity {
4886    #[serde(rename = "canRead")]
4887    pub can_read: Option<bool>,
4888    #[serde(rename = "statusHistory")]
4889    pub status_history: Option<StatusHistoryDto>,
4890}
4891
4892#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4893#[serde(rename_all = "camelCase")]
4894pub struct StatusSnapshotDto {
4895    #[serde(rename = "statusMetrics")]
4896    pub status_metrics: Option<std::collections::HashMap<String, Option<i64>>>,
4897    pub timestamp: Option<String>,
4898}
4899
4900#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4901#[serde(rename_all = "camelCase")]
4902pub struct StorageUsageDto {
4903    #[serde(rename = "freeSpace")]
4904    pub free_space: Option<String>,
4905    #[serde(rename = "freeSpaceBytes")]
4906    pub free_space_bytes: Option<i64>,
4907    pub identifier: Option<String>,
4908    #[serde(rename = "totalSpace")]
4909    pub total_space: Option<String>,
4910    #[serde(rename = "totalSpaceBytes")]
4911    pub total_space_bytes: Option<i64>,
4912    #[serde(rename = "usedSpace")]
4913    pub used_space: Option<String>,
4914    #[serde(rename = "usedSpaceBytes")]
4915    pub used_space_bytes: Option<i64>,
4916    pub utilization: Option<String>,
4917}
4918
4919#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4920#[serde(rename_all = "camelCase")]
4921pub struct StreamingOutput {}
4922
4923#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4924#[serde(rename_all = "camelCase")]
4925pub struct SubmitReplayRequestEntity {
4926    #[serde(rename = "clusterNodeId")]
4927    pub cluster_node_id: Option<String>,
4928    #[serde(rename = "eventId")]
4929    pub event_id: Option<i64>,
4930}
4931
4932#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4933#[serde(rename_all = "camelCase")]
4934pub struct SupportedMimeTypesDto {
4935    #[serde(rename = "displayName")]
4936    pub display_name: Option<String>,
4937    #[serde(rename = "mimeTypes")]
4938    pub mime_types: Option<Vec<String>>,
4939}
4940
4941#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4942#[serde(rename_all = "camelCase")]
4943pub struct SystemDiagnosticsDto {
4944    #[serde(rename = "aggregateSnapshot")]
4945    pub aggregate_snapshot: Option<SystemDiagnosticsSnapshotDto>,
4946    #[serde(rename = "nodeSnapshots")]
4947    pub node_snapshots: Option<Vec<NodeSystemDiagnosticsSnapshotDto>>,
4948}
4949
4950#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4951#[serde(rename_all = "camelCase")]
4952pub(crate) struct SystemDiagnosticsEntity {
4953    pub system_diagnostics: Option<SystemDiagnosticsDto>,
4954}
4955
4956#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4957#[serde(rename_all = "camelCase")]
4958pub struct SystemDiagnosticsSnapshotDto {
4959    #[serde(rename = "availableProcessors")]
4960    pub available_processors: Option<i32>,
4961    #[serde(rename = "contentRepositoryStorageUsage")]
4962    pub content_repository_storage_usage: Option<Vec<StorageUsageDto>>,
4963    #[serde(rename = "daemonThreads")]
4964    pub daemon_threads: Option<i32>,
4965    #[serde(rename = "flowFileRepositoryStorageUsage")]
4966    pub flow_file_repository_storage_usage: Option<StorageUsageDto>,
4967    #[serde(rename = "freeHeap")]
4968    pub free_heap: Option<String>,
4969    #[serde(rename = "freeHeapBytes")]
4970    pub free_heap_bytes: Option<i64>,
4971    #[serde(rename = "freeNonHeap")]
4972    pub free_non_heap: Option<String>,
4973    #[serde(rename = "freeNonHeapBytes")]
4974    pub free_non_heap_bytes: Option<i64>,
4975    #[serde(rename = "garbageCollection")]
4976    pub garbage_collection: Option<Vec<GarbageCollectionDto>>,
4977    #[serde(rename = "heapUtilization")]
4978    pub heap_utilization: Option<String>,
4979    #[serde(rename = "maxHeap")]
4980    pub max_heap: Option<String>,
4981    #[serde(rename = "maxHeapBytes")]
4982    pub max_heap_bytes: Option<i64>,
4983    #[serde(rename = "maxNonHeap")]
4984    pub max_non_heap: Option<String>,
4985    #[serde(rename = "maxNonHeapBytes")]
4986    pub max_non_heap_bytes: Option<i64>,
4987    #[serde(rename = "nonHeapUtilization")]
4988    pub non_heap_utilization: Option<String>,
4989    #[serde(rename = "processorLoadAverage")]
4990    pub processor_load_average: Option<f64>,
4991    #[serde(rename = "provenanceRepositoryStorageUsage")]
4992    pub provenance_repository_storage_usage: Option<Vec<StorageUsageDto>>,
4993    #[serde(rename = "resourceClaimDetails")]
4994    pub resource_claim_details: Option<Vec<ResourceClaimDetailsDto>>,
4995    #[serde(rename = "statsLastRefreshed")]
4996    pub stats_last_refreshed: Option<String>,
4997    #[serde(rename = "totalHeap")]
4998    pub total_heap: Option<String>,
4999    #[serde(rename = "totalHeapBytes")]
5000    pub total_heap_bytes: Option<i64>,
5001    #[serde(rename = "totalNonHeap")]
5002    pub total_non_heap: Option<String>,
5003    #[serde(rename = "totalNonHeapBytes")]
5004    pub total_non_heap_bytes: Option<i64>,
5005    #[serde(rename = "totalThreads")]
5006    pub total_threads: Option<i32>,
5007    pub uptime: Option<String>,
5008    #[serde(rename = "usedHeap")]
5009    pub used_heap: Option<String>,
5010    #[serde(rename = "usedHeapBytes")]
5011    pub used_heap_bytes: Option<i64>,
5012    #[serde(rename = "usedNonHeap")]
5013    pub used_non_heap: Option<String>,
5014    #[serde(rename = "usedNonHeapBytes")]
5015    pub used_non_heap_bytes: Option<i64>,
5016    #[serde(rename = "versionInfo")]
5017    pub version_info: Option<VersionInfoDto>,
5018}
5019
5020#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5021#[serde(rename_all = "camelCase")]
5022pub struct SystemResourceConsideration {
5023    pub description: Option<String>,
5024    pub resource: Option<String>,
5025}
5026
5027#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5028#[serde(rename_all = "camelCase")]
5029pub struct TenantDto {
5030    pub configurable: Option<bool>,
5031    pub id: Option<String>,
5032    pub identity: Option<String>,
5033    #[serde(rename = "parentGroupId")]
5034    pub parent_group_id: Option<String>,
5035    pub position: Option<PositionDto>,
5036    #[serde(rename = "versionedComponentId")]
5037    pub versioned_component_id: Option<String>,
5038}
5039
5040#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5041#[serde(rename_all = "camelCase")]
5042pub struct TenantEntity {
5043    pub bulletins: Option<Vec<BulletinEntity>>,
5044    pub component: Option<TenantDto>,
5045    #[serde(rename = "disconnectedNodeAcknowledged")]
5046    pub disconnected_node_acknowledged: Option<bool>,
5047    pub id: Option<String>,
5048    pub permissions: Option<PermissionsDto>,
5049    pub position: Option<PositionDto>,
5050    pub revision: Option<RevisionDto>,
5051    pub uri: Option<String>,
5052}
5053
5054#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5055#[serde(rename_all = "camelCase")]
5056pub struct TenantsEntity {
5057    #[serde(rename = "userGroups")]
5058    pub user_groups: Option<Vec<TenantEntity>>,
5059    pub users: Option<Vec<TenantEntity>>,
5060}
5061
5062#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5063#[serde(rename_all = "camelCase")]
5064pub struct TransactionResultEntity {
5065    #[serde(rename = "flowFileSent")]
5066    pub flow_file_sent: Option<i32>,
5067    pub message: Option<String>,
5068    #[serde(rename = "responseCode")]
5069    pub response_code: Option<i32>,
5070}
5071
5072#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5073#[serde(rename_all = "camelCase")]
5074pub struct UpdateControllerServiceReferenceRequestEntity {
5075    #[serde(rename = "disconnectedNodeAcknowledged")]
5076    pub disconnected_node_acknowledged: Option<bool>,
5077    pub id: Option<String>,
5078    #[serde(rename = "referencingComponentRevisions")]
5079    pub referencing_component_revisions:
5080        Option<std::collections::HashMap<String, Option<RevisionDto>>>,
5081    pub state: Option<String>,
5082    #[serde(rename = "uiOnly")]
5083    pub ui_only: Option<bool>,
5084}
5085
5086#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5087#[serde(rename_all = "camelCase")]
5088pub struct UseCase {
5089    pub configuration: Option<String>,
5090    pub description: Option<String>,
5091    #[serde(rename = "inputRequirement")]
5092    pub input_requirement: Option<String>,
5093    pub keywords: Option<Vec<String>>,
5094    pub notes: Option<String>,
5095}
5096
5097#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5098#[serde(rename_all = "camelCase")]
5099pub struct UserDto {
5100    #[serde(rename = "accessPolicies")]
5101    pub access_policies: Option<Vec<AccessPolicySummaryEntity>>,
5102    pub configurable: Option<bool>,
5103    pub id: Option<String>,
5104    pub identity: Option<String>,
5105    #[serde(rename = "parentGroupId")]
5106    pub parent_group_id: Option<String>,
5107    pub position: Option<PositionDto>,
5108    #[serde(rename = "userGroups")]
5109    pub user_groups: Option<Vec<TenantEntity>>,
5110    #[serde(rename = "versionedComponentId")]
5111    pub versioned_component_id: Option<String>,
5112}
5113
5114#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5115#[serde(rename_all = "camelCase")]
5116pub struct UserEntity {
5117    pub bulletins: Option<Vec<BulletinEntity>>,
5118    pub component: Option<UserDto>,
5119    #[serde(rename = "disconnectedNodeAcknowledged")]
5120    pub disconnected_node_acknowledged: Option<bool>,
5121    pub id: Option<String>,
5122    pub permissions: Option<PermissionsDto>,
5123    pub position: Option<PositionDto>,
5124    pub revision: Option<RevisionDto>,
5125    pub uri: Option<String>,
5126}
5127
5128#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5129#[serde(rename_all = "camelCase")]
5130pub struct UserGroupDto {
5131    #[serde(rename = "accessPolicies")]
5132    pub access_policies: Option<Vec<AccessPolicyEntity>>,
5133    pub configurable: Option<bool>,
5134    pub id: Option<String>,
5135    pub identity: Option<String>,
5136    #[serde(rename = "parentGroupId")]
5137    pub parent_group_id: Option<String>,
5138    pub position: Option<PositionDto>,
5139    pub users: Option<Vec<TenantEntity>>,
5140    #[serde(rename = "versionedComponentId")]
5141    pub versioned_component_id: Option<String>,
5142}
5143
5144#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5145#[serde(rename_all = "camelCase")]
5146pub struct UserGroupEntity {
5147    pub bulletins: Option<Vec<BulletinEntity>>,
5148    pub component: Option<UserGroupDto>,
5149    #[serde(rename = "disconnectedNodeAcknowledged")]
5150    pub disconnected_node_acknowledged: Option<bool>,
5151    pub id: Option<String>,
5152    pub permissions: Option<PermissionsDto>,
5153    pub position: Option<PositionDto>,
5154    pub revision: Option<RevisionDto>,
5155    pub uri: Option<String>,
5156}
5157
5158#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5159#[serde(rename_all = "camelCase")]
5160pub struct UserGroupsEntity {
5161    #[serde(rename = "userGroups")]
5162    pub user_groups: Option<Vec<UserGroupEntity>>,
5163}
5164
5165#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5166#[serde(rename_all = "camelCase")]
5167pub struct UsersEntity {
5168    pub generated: Option<String>,
5169    pub users: Option<Vec<UserEntity>>,
5170}
5171
5172#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5173#[serde(rename_all = "camelCase")]
5174pub struct VerifyConfigRequestDto {
5175    pub attributes: Option<std::collections::HashMap<String, Option<String>>>,
5176    pub complete: Option<bool>,
5177    #[serde(rename = "componentId")]
5178    pub component_id: Option<String>,
5179    #[serde(rename = "failureReason")]
5180    pub failure_reason: Option<String>,
5181    #[serde(rename = "lastUpdated")]
5182    pub last_updated: Option<String>,
5183    #[serde(rename = "percentCompleted")]
5184    pub percent_completed: Option<i32>,
5185    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
5186    #[serde(rename = "requestId")]
5187    pub request_id: Option<String>,
5188    pub results: Option<Vec<ConfigVerificationResultDto>>,
5189    pub state: Option<String>,
5190    #[serde(rename = "submissionTime")]
5191    pub submission_time: Option<String>,
5192    #[serde(rename = "updateSteps")]
5193    pub update_steps: Option<Vec<VerifyConfigUpdateStepDto>>,
5194    pub uri: Option<String>,
5195}
5196
5197#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5198#[serde(rename_all = "camelCase")]
5199pub(crate) struct VerifyConfigRequestEntity {
5200    pub request: Option<VerifyConfigRequestDto>,
5201}
5202
5203#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5204#[serde(rename_all = "camelCase")]
5205pub struct VerifyConfigUpdateStepDto {
5206    pub complete: Option<bool>,
5207    pub description: Option<String>,
5208    #[serde(rename = "failureReason")]
5209    pub failure_reason: Option<String>,
5210}
5211
5212#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5213#[serde(rename_all = "camelCase")]
5214pub struct VersionControlComponentMappingEntity {
5215    #[serde(rename = "disconnectedNodeAcknowledged")]
5216    pub disconnected_node_acknowledged: Option<bool>,
5217    #[serde(rename = "processGroupRevision")]
5218    pub process_group_revision: Option<RevisionDto>,
5219    #[serde(rename = "versionControlComponentMapping")]
5220    pub version_control_component_mapping:
5221        Option<std::collections::HashMap<String, Option<String>>>,
5222    #[serde(rename = "versionControlInformation")]
5223    pub version_control_information: Option<VersionControlInformationDto>,
5224}
5225
5226#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5227#[serde(rename_all = "camelCase")]
5228pub struct VersionControlInformationDto {
5229    pub branch: Option<String>,
5230    #[serde(rename = "bucketId")]
5231    pub bucket_id: Option<String>,
5232    #[serde(rename = "bucketName")]
5233    pub bucket_name: Option<String>,
5234    #[serde(rename = "flowDescription")]
5235    pub flow_description: Option<String>,
5236    #[serde(rename = "flowId")]
5237    pub flow_id: Option<String>,
5238    #[serde(rename = "flowName")]
5239    pub flow_name: Option<String>,
5240    #[serde(rename = "groupId")]
5241    pub group_id: Option<String>,
5242    #[serde(rename = "registryId")]
5243    pub registry_id: Option<String>,
5244    #[serde(rename = "registryName")]
5245    pub registry_name: Option<String>,
5246    pub state: Option<String>,
5247    #[serde(rename = "stateExplanation")]
5248    pub state_explanation: Option<String>,
5249    #[serde(rename = "storageLocation")]
5250    pub storage_location: Option<String>,
5251    pub version: Option<String>,
5252}
5253
5254#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5255#[serde(rename_all = "camelCase")]
5256pub struct VersionControlInformationEntity {
5257    #[serde(rename = "disconnectedNodeAcknowledged")]
5258    pub disconnected_node_acknowledged: Option<bool>,
5259    #[serde(rename = "processGroupRevision")]
5260    pub process_group_revision: Option<RevisionDto>,
5261    #[serde(rename = "versionControlInformation")]
5262    pub version_control_information: Option<VersionControlInformationDto>,
5263}
5264
5265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5266#[serde(rename_all = "camelCase")]
5267pub struct VersionInfoDto {
5268    #[serde(rename = "buildBranch")]
5269    pub build_branch: Option<String>,
5270    #[serde(rename = "buildRevision")]
5271    pub build_revision: Option<String>,
5272    #[serde(rename = "buildTag")]
5273    pub build_tag: Option<String>,
5274    #[serde(rename = "buildTimestamp")]
5275    pub build_timestamp: Option<String>,
5276    #[serde(rename = "javaVendor")]
5277    pub java_vendor: Option<String>,
5278    #[serde(rename = "javaVersion")]
5279    pub java_version: Option<String>,
5280    #[serde(rename = "niFiVersion")]
5281    pub ni_fi_version: Option<String>,
5282    #[serde(rename = "osArchitecture")]
5283    pub os_architecture: Option<String>,
5284    #[serde(rename = "osName")]
5285    pub os_name: Option<String>,
5286    #[serde(rename = "osVersion")]
5287    pub os_version: Option<String>,
5288}
5289
5290#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5291#[serde(rename_all = "camelCase")]
5292pub struct VersionedAsset {
5293    pub identifier: Option<String>,
5294    pub name: Option<String>,
5295}
5296
5297#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5298#[serde(rename_all = "camelCase")]
5299pub struct VersionedConnection {
5300    #[serde(rename = "backPressureDataSizeThreshold")]
5301    pub back_pressure_data_size_threshold: Option<String>,
5302    #[serde(rename = "backPressureObjectThreshold")]
5303    pub back_pressure_object_threshold: Option<i64>,
5304    pub bends: Option<Vec<Position>>,
5305    pub comments: Option<String>,
5306    #[serde(rename = "componentType")]
5307    pub component_type: Option<String>,
5308    pub destination: Option<ConnectableComponent>,
5309    #[serde(rename = "flowFileExpiration")]
5310    pub flow_file_expiration: Option<String>,
5311    #[serde(rename = "groupIdentifier")]
5312    pub group_identifier: Option<String>,
5313    pub identifier: Option<String>,
5314    #[serde(rename = "instanceIdentifier")]
5315    pub instance_identifier: Option<String>,
5316    #[serde(rename = "labelIndex")]
5317    pub label_index: Option<i32>,
5318    #[serde(rename = "loadBalanceCompression")]
5319    pub load_balance_compression: Option<String>,
5320    #[serde(rename = "loadBalanceStrategy")]
5321    pub load_balance_strategy: Option<String>,
5322    pub name: Option<String>,
5323    #[serde(rename = "partitioningAttribute")]
5324    pub partitioning_attribute: Option<String>,
5325    pub position: Option<Position>,
5326    pub prioritizers: Option<Vec<String>>,
5327    #[serde(rename = "selectedRelationships")]
5328    pub selected_relationships: Option<Vec<String>>,
5329    pub source: Option<ConnectableComponent>,
5330    #[serde(rename = "zIndex")]
5331    pub z_index: Option<i64>,
5332}
5333
5334#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5335#[serde(rename_all = "camelCase")]
5336pub struct VersionedControllerService {
5337    #[serde(rename = "annotationData")]
5338    pub annotation_data: Option<String>,
5339    #[serde(rename = "bulletinLevel")]
5340    pub bulletin_level: Option<String>,
5341    pub bundle: Option<Bundle>,
5342    pub comments: Option<String>,
5343    #[serde(rename = "componentType")]
5344    pub component_type: Option<String>,
5345    #[serde(rename = "controllerServiceApis")]
5346    pub controller_service_apis: Option<Vec<ControllerServiceAPI>>,
5347    #[serde(rename = "groupIdentifier")]
5348    pub group_identifier: Option<String>,
5349    pub identifier: Option<String>,
5350    #[serde(rename = "instanceIdentifier")]
5351    pub instance_identifier: Option<String>,
5352    pub name: Option<String>,
5353    pub position: Option<Position>,
5354    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
5355    #[serde(rename = "propertyDescriptors")]
5356    pub property_descriptors:
5357        Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
5358    #[serde(rename = "scheduledState")]
5359    pub scheduled_state: Option<String>,
5360    pub r#type: Option<String>,
5361}
5362
5363#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5364#[serde(rename_all = "camelCase")]
5365pub struct VersionedFlowCoordinates {
5366    pub branch: Option<String>,
5367    #[serde(rename = "bucketId")]
5368    pub bucket_id: Option<String>,
5369    #[serde(rename = "flowId")]
5370    pub flow_id: Option<String>,
5371    pub latest: Option<bool>,
5372    #[serde(rename = "registryId")]
5373    pub registry_id: Option<String>,
5374    #[serde(rename = "storageLocation")]
5375    pub storage_location: Option<String>,
5376    pub version: Option<String>,
5377}
5378
5379#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5380#[serde(rename_all = "camelCase")]
5381pub struct VersionedFlowDto {
5382    pub action: Option<String>,
5383    pub branch: Option<String>,
5384    #[serde(rename = "bucketId")]
5385    pub bucket_id: Option<String>,
5386    pub comments: Option<String>,
5387    pub description: Option<String>,
5388    #[serde(rename = "flowId")]
5389    pub flow_id: Option<String>,
5390    #[serde(rename = "flowName")]
5391    pub flow_name: Option<String>,
5392    #[serde(rename = "registryId")]
5393    pub registry_id: Option<String>,
5394}
5395
5396#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5397#[serde(rename_all = "camelCase")]
5398pub(crate) struct VersionedFlowEntity {
5399    pub versioned_flow: Option<VersionedFlowDto>,
5400}
5401
5402#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5403#[serde(rename_all = "camelCase")]
5404pub struct VersionedFlowSnapshotEntity {
5405    #[serde(rename = "disconnectedNodeAcknowledged")]
5406    pub disconnected_node_acknowledged: Option<bool>,
5407    #[serde(rename = "processGroupRevision")]
5408    pub process_group_revision: Option<RevisionDto>,
5409    #[serde(rename = "registryId")]
5410    pub registry_id: Option<String>,
5411    #[serde(rename = "updateDescendantVersionedFlows")]
5412    pub update_descendant_versioned_flows: Option<bool>,
5413    #[serde(rename = "versionedFlow")]
5414    pub versioned_flow: Option<RegisteredFlowSnapshot>,
5415    #[serde(rename = "versionedFlowSnapshot")]
5416    pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
5417}
5418
5419#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5420#[serde(rename_all = "camelCase")]
5421pub struct VersionedFlowSnapshotMetadataEntity {
5422    #[serde(rename = "registryId")]
5423    pub registry_id: Option<String>,
5424    #[serde(rename = "versionedFlowSnapshotMetadata")]
5425    pub versioned_flow_snapshot_metadata: Option<RegisteredFlowSnapshotMetadata>,
5426}
5427
5428#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5429#[serde(rename_all = "camelCase")]
5430pub struct VersionedFlowSnapshotMetadataSetEntity {
5431    #[serde(rename = "versionedFlowSnapshotMetadataSet")]
5432    pub versioned_flow_snapshot_metadata_set: Option<Vec<VersionedFlowSnapshotMetadataEntity>>,
5433}
5434
5435#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5436#[serde(rename_all = "camelCase")]
5437pub struct VersionedFlowUpdateRequestDto {
5438    pub complete: Option<bool>,
5439    #[serde(rename = "failureReason")]
5440    pub failure_reason: Option<String>,
5441    #[serde(rename = "lastUpdated")]
5442    pub last_updated: Option<String>,
5443    #[serde(rename = "percentCompleted")]
5444    pub percent_completed: Option<i32>,
5445    #[serde(rename = "processGroupId")]
5446    pub process_group_id: Option<String>,
5447    #[serde(rename = "requestId")]
5448    pub request_id: Option<String>,
5449    pub state: Option<String>,
5450    pub uri: Option<String>,
5451    #[serde(rename = "versionControlInformation")]
5452    pub version_control_information: Option<VersionControlInformationDto>,
5453}
5454
5455#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5456#[serde(rename_all = "camelCase")]
5457pub struct VersionedFlowUpdateRequestEntity {
5458    #[serde(rename = "processGroupRevision")]
5459    pub process_group_revision: Option<RevisionDto>,
5460    pub request: Option<VersionedFlowUpdateRequestDto>,
5461}
5462
5463#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5464#[serde(rename_all = "camelCase")]
5465pub struct VersionedFlowsEntity {
5466    #[serde(rename = "versionedFlows")]
5467    pub versioned_flows: Option<Vec<VersionedFlowEntity>>,
5468}
5469
5470#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5471#[serde(rename_all = "camelCase")]
5472pub struct VersionedFunnel {
5473    pub comments: Option<String>,
5474    #[serde(rename = "componentType")]
5475    pub component_type: Option<String>,
5476    #[serde(rename = "groupIdentifier")]
5477    pub group_identifier: Option<String>,
5478    pub identifier: Option<String>,
5479    #[serde(rename = "instanceIdentifier")]
5480    pub instance_identifier: Option<String>,
5481    pub name: Option<String>,
5482    pub position: Option<Position>,
5483}
5484
5485#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5486#[serde(rename_all = "camelCase")]
5487pub struct VersionedLabel {
5488    pub comments: Option<String>,
5489    #[serde(rename = "componentType")]
5490    pub component_type: Option<String>,
5491    #[serde(rename = "groupIdentifier")]
5492    pub group_identifier: Option<String>,
5493    pub height: Option<f64>,
5494    pub identifier: Option<String>,
5495    #[serde(rename = "instanceIdentifier")]
5496    pub instance_identifier: Option<String>,
5497    pub label: Option<String>,
5498    pub name: Option<String>,
5499    pub position: Option<Position>,
5500    pub style: Option<std::collections::HashMap<String, Option<String>>>,
5501    pub width: Option<f64>,
5502    #[serde(rename = "zIndex")]
5503    pub z_index: Option<i64>,
5504}
5505
5506#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5507#[serde(rename_all = "camelCase")]
5508pub struct VersionedListenPortDefinition {
5509    #[serde(rename = "applicationProtocols")]
5510    pub application_protocols: Option<Vec<String>>,
5511    #[serde(rename = "transportProtocol")]
5512    pub transport_protocol: Option<String>,
5513}
5514
5515#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5516#[serde(rename_all = "camelCase")]
5517pub struct VersionedParameter {
5518    pub description: Option<String>,
5519    pub name: Option<String>,
5520    pub provided: Option<bool>,
5521    #[serde(rename = "referencedAssets")]
5522    pub referenced_assets: Option<Vec<VersionedAsset>>,
5523    pub sensitive: Option<bool>,
5524    pub value: Option<String>,
5525}
5526
5527#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5528#[serde(rename_all = "camelCase")]
5529pub struct VersionedParameterContext {
5530    pub comments: Option<String>,
5531    #[serde(rename = "componentType")]
5532    pub component_type: Option<String>,
5533    pub description: Option<String>,
5534    #[serde(rename = "groupIdentifier")]
5535    pub group_identifier: Option<String>,
5536    pub identifier: Option<String>,
5537    #[serde(rename = "inheritedParameterContexts")]
5538    pub inherited_parameter_contexts: Option<Vec<String>>,
5539    #[serde(rename = "instanceIdentifier")]
5540    pub instance_identifier: Option<String>,
5541    pub name: Option<String>,
5542    #[serde(rename = "parameterGroupName")]
5543    pub parameter_group_name: Option<String>,
5544    #[serde(rename = "parameterProvider")]
5545    pub parameter_provider: Option<String>,
5546    pub parameters: Option<Vec<VersionedParameter>>,
5547    pub position: Option<Position>,
5548    pub synchronized: Option<bool>,
5549}
5550
5551#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5552#[serde(rename_all = "camelCase")]
5553pub struct VersionedPort {
5554    #[serde(rename = "allowRemoteAccess")]
5555    pub allow_remote_access: Option<bool>,
5556    pub comments: Option<String>,
5557    #[serde(rename = "componentType")]
5558    pub component_type: Option<String>,
5559    #[serde(rename = "concurrentlySchedulableTaskCount")]
5560    pub concurrently_schedulable_task_count: Option<i32>,
5561    #[serde(rename = "groupIdentifier")]
5562    pub group_identifier: Option<String>,
5563    pub identifier: Option<String>,
5564    #[serde(rename = "instanceIdentifier")]
5565    pub instance_identifier: Option<String>,
5566    pub name: Option<String>,
5567    #[serde(rename = "portFunction")]
5568    pub port_function: Option<String>,
5569    pub position: Option<Position>,
5570    #[serde(rename = "scheduledState")]
5571    pub scheduled_state: Option<String>,
5572    pub r#type: Option<String>,
5573}
5574
5575#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5576#[serde(rename_all = "camelCase")]
5577pub struct VersionedProcessGroup {
5578    pub comments: Option<String>,
5579    #[serde(rename = "componentType")]
5580    pub component_type: Option<String>,
5581    pub connections: Option<Vec<VersionedConnection>>,
5582    #[serde(rename = "controllerServices")]
5583    pub controller_services: Option<Vec<VersionedControllerService>>,
5584    #[serde(rename = "defaultBackPressureDataSizeThreshold")]
5585    pub default_back_pressure_data_size_threshold: Option<String>,
5586    #[serde(rename = "defaultBackPressureObjectThreshold")]
5587    pub default_back_pressure_object_threshold: Option<i64>,
5588    #[serde(rename = "defaultFlowFileExpiration")]
5589    pub default_flow_file_expiration: Option<String>,
5590    #[serde(rename = "executionEngine")]
5591    pub execution_engine: Option<String>,
5592    #[serde(rename = "flowFileConcurrency")]
5593    pub flow_file_concurrency: Option<String>,
5594    #[serde(rename = "flowFileOutboundPolicy")]
5595    pub flow_file_outbound_policy: Option<String>,
5596    pub funnels: Option<Vec<VersionedFunnel>>,
5597    #[serde(rename = "groupIdentifier")]
5598    pub group_identifier: Option<String>,
5599    pub identifier: Option<String>,
5600    #[serde(rename = "inputPorts")]
5601    pub input_ports: Option<Vec<VersionedPort>>,
5602    #[serde(rename = "instanceIdentifier")]
5603    pub instance_identifier: Option<String>,
5604    pub labels: Option<Vec<VersionedLabel>>,
5605    #[serde(rename = "logFileSuffix")]
5606    pub log_file_suffix: Option<String>,
5607    #[serde(rename = "maxConcurrentTasks")]
5608    pub max_concurrent_tasks: Option<i32>,
5609    pub name: Option<String>,
5610    #[serde(rename = "outputPorts")]
5611    pub output_ports: Option<Vec<VersionedPort>>,
5612    #[serde(rename = "parameterContextName")]
5613    pub parameter_context_name: Option<String>,
5614    pub position: Option<Position>,
5615    #[serde(rename = "processGroups")]
5616    pub process_groups: Option<Vec<Box<VersionedProcessGroup>>>,
5617    pub processors: Option<Vec<VersionedProcessor>>,
5618    #[serde(rename = "remoteProcessGroups")]
5619    pub remote_process_groups: Option<Vec<VersionedRemoteProcessGroup>>,
5620    #[serde(rename = "scheduledState")]
5621    pub scheduled_state: Option<String>,
5622    #[serde(rename = "statelessFlowTimeout")]
5623    pub stateless_flow_timeout: Option<String>,
5624    #[serde(rename = "versionedFlowCoordinates")]
5625    pub versioned_flow_coordinates: Option<VersionedFlowCoordinates>,
5626}
5627
5628#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5629#[serde(rename_all = "camelCase")]
5630pub struct VersionedProcessor {
5631    #[serde(rename = "annotationData")]
5632    pub annotation_data: Option<String>,
5633    #[serde(rename = "autoTerminatedRelationships")]
5634    pub auto_terminated_relationships: Option<Vec<String>>,
5635    #[serde(rename = "backoffMechanism")]
5636    pub backoff_mechanism: Option<String>,
5637    #[serde(rename = "bulletinLevel")]
5638    pub bulletin_level: Option<String>,
5639    pub bundle: Option<Bundle>,
5640    pub comments: Option<String>,
5641    #[serde(rename = "componentType")]
5642    pub component_type: Option<String>,
5643    #[serde(rename = "concurrentlySchedulableTaskCount")]
5644    pub concurrently_schedulable_task_count: Option<i32>,
5645    #[serde(rename = "executionNode")]
5646    pub execution_node: Option<String>,
5647    #[serde(rename = "groupIdentifier")]
5648    pub group_identifier: Option<String>,
5649    pub identifier: Option<String>,
5650    #[serde(rename = "instanceIdentifier")]
5651    pub instance_identifier: Option<String>,
5652    #[serde(rename = "maxBackoffPeriod")]
5653    pub max_backoff_period: Option<String>,
5654    pub name: Option<String>,
5655    #[serde(rename = "penaltyDuration")]
5656    pub penalty_duration: Option<String>,
5657    pub position: Option<Position>,
5658    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
5659    #[serde(rename = "propertyDescriptors")]
5660    pub property_descriptors:
5661        Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
5662    #[serde(rename = "retriedRelationships")]
5663    pub retried_relationships: Option<Vec<String>>,
5664    #[serde(rename = "retryCount")]
5665    pub retry_count: Option<i32>,
5666    #[serde(rename = "runDurationMillis")]
5667    pub run_duration_millis: Option<i64>,
5668    #[serde(rename = "scheduledState")]
5669    pub scheduled_state: Option<String>,
5670    #[serde(rename = "schedulingPeriod")]
5671    pub scheduling_period: Option<String>,
5672    #[serde(rename = "schedulingStrategy")]
5673    pub scheduling_strategy: Option<String>,
5674    pub style: Option<std::collections::HashMap<String, Option<String>>>,
5675    pub r#type: Option<String>,
5676    #[serde(rename = "yieldDuration")]
5677    pub yield_duration: Option<String>,
5678}
5679
5680#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5681#[serde(rename_all = "camelCase")]
5682pub struct VersionedPropertyDescriptor {
5683    #[serde(rename = "displayName")]
5684    pub display_name: Option<String>,
5685    pub dynamic: Option<bool>,
5686    #[serde(rename = "identifiesControllerService")]
5687    pub identifies_controller_service: Option<bool>,
5688    #[serde(rename = "listenPortDefinition")]
5689    pub listen_port_definition: Option<VersionedListenPortDefinition>,
5690    pub name: Option<String>,
5691    #[serde(rename = "resourceDefinition")]
5692    pub resource_definition: Option<VersionedResourceDefinition>,
5693    pub sensitive: Option<bool>,
5694}
5695
5696#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5697#[serde(rename_all = "camelCase")]
5698pub struct VersionedRemoteGroupPort {
5699    #[serde(rename = "batchSize")]
5700    pub batch_size: Option<BatchSize>,
5701    pub comments: Option<String>,
5702    #[serde(rename = "componentType")]
5703    pub component_type: Option<String>,
5704    #[serde(rename = "concurrentlySchedulableTaskCount")]
5705    pub concurrently_schedulable_task_count: Option<i32>,
5706    #[serde(rename = "groupIdentifier")]
5707    pub group_identifier: Option<String>,
5708    pub identifier: Option<String>,
5709    #[serde(rename = "instanceIdentifier")]
5710    pub instance_identifier: Option<String>,
5711    pub name: Option<String>,
5712    pub position: Option<Position>,
5713    #[serde(rename = "remoteGroupId")]
5714    pub remote_group_id: Option<String>,
5715    #[serde(rename = "scheduledState")]
5716    pub scheduled_state: Option<String>,
5717    #[serde(rename = "targetId")]
5718    pub target_id: Option<String>,
5719    #[serde(rename = "useCompression")]
5720    pub use_compression: Option<bool>,
5721}
5722
5723#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5724#[serde(rename_all = "camelCase")]
5725pub struct VersionedRemoteProcessGroup {
5726    pub comments: Option<String>,
5727    #[serde(rename = "communicationsTimeout")]
5728    pub communications_timeout: Option<String>,
5729    #[serde(rename = "componentType")]
5730    pub component_type: Option<String>,
5731    #[serde(rename = "groupIdentifier")]
5732    pub group_identifier: Option<String>,
5733    pub identifier: Option<String>,
5734    #[serde(rename = "inputPorts")]
5735    pub input_ports: Option<Vec<VersionedRemoteGroupPort>>,
5736    #[serde(rename = "instanceIdentifier")]
5737    pub instance_identifier: Option<String>,
5738    #[serde(rename = "localNetworkInterface")]
5739    pub local_network_interface: Option<String>,
5740    pub name: Option<String>,
5741    #[serde(rename = "outputPorts")]
5742    pub output_ports: Option<Vec<VersionedRemoteGroupPort>>,
5743    pub position: Option<Position>,
5744    #[serde(rename = "proxyHost")]
5745    pub proxy_host: Option<String>,
5746    #[serde(rename = "proxyPassword")]
5747    pub proxy_password: Option<String>,
5748    #[serde(rename = "proxyPort")]
5749    pub proxy_port: Option<i32>,
5750    #[serde(rename = "proxyUser")]
5751    pub proxy_user: Option<String>,
5752    #[serde(rename = "targetUris")]
5753    pub target_uris: Option<String>,
5754    #[serde(rename = "transportProtocol")]
5755    pub transport_protocol: Option<String>,
5756    #[serde(rename = "yieldDuration")]
5757    pub yield_duration: Option<String>,
5758}
5759
5760#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5761#[serde(rename_all = "camelCase")]
5762pub struct VersionedReportingTask {
5763    #[serde(rename = "annotationData")]
5764    pub annotation_data: Option<String>,
5765    pub bundle: Option<Bundle>,
5766    pub comments: Option<String>,
5767    #[serde(rename = "componentType")]
5768    pub component_type: Option<String>,
5769    #[serde(rename = "groupIdentifier")]
5770    pub group_identifier: Option<String>,
5771    pub identifier: Option<String>,
5772    #[serde(rename = "instanceIdentifier")]
5773    pub instance_identifier: Option<String>,
5774    pub name: Option<String>,
5775    pub position: Option<Position>,
5776    pub properties: Option<std::collections::HashMap<String, Option<String>>>,
5777    #[serde(rename = "propertyDescriptors")]
5778    pub property_descriptors:
5779        Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
5780    #[serde(rename = "scheduledState")]
5781    pub scheduled_state: Option<String>,
5782    #[serde(rename = "schedulingPeriod")]
5783    pub scheduling_period: Option<String>,
5784    #[serde(rename = "schedulingStrategy")]
5785    pub scheduling_strategy: Option<String>,
5786    pub r#type: Option<String>,
5787}
5788
5789#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5790#[serde(rename_all = "camelCase")]
5791pub struct VersionedReportingTaskImportRequestEntity {
5792    #[serde(rename = "disconnectedNodeAcknowledged")]
5793    pub disconnected_node_acknowledged: Option<bool>,
5794    #[serde(rename = "reportingTaskSnapshot")]
5795    pub reporting_task_snapshot: Option<VersionedReportingTaskSnapshot>,
5796}
5797
5798#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5799#[serde(rename_all = "camelCase")]
5800pub struct VersionedReportingTaskImportResponseEntity {
5801    #[serde(rename = "controllerServices")]
5802    pub controller_services: Option<Vec<ControllerServiceEntity>>,
5803    #[serde(rename = "reportingTasks")]
5804    pub reporting_tasks: Option<Vec<ReportingTaskEntity>>,
5805}
5806
5807#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5808#[serde(rename_all = "camelCase")]
5809pub struct VersionedReportingTaskSnapshot {
5810    #[serde(rename = "controllerServices")]
5811    pub controller_services: Option<Vec<VersionedControllerService>>,
5812    #[serde(rename = "reportingTasks")]
5813    pub reporting_tasks: Option<Vec<VersionedReportingTask>>,
5814}
5815
5816#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5817#[serde(rename_all = "camelCase")]
5818pub struct VersionedResourceDefinition {
5819    pub cardinality: Option<String>,
5820    #[serde(rename = "resourceTypes")]
5821    pub resource_types: Option<Vec<String>>,
5822}
nifi_rust_client/dynamic/types.rs

nifi_rust_client/dynamic/
types.rs
